v1.0.17: modern multi-color app icon with depth and detail

Redesigned launcher icon:
- Background: deep violet #2E1065 → purple #6D28D9 → navy #1E40AF
- Three concentric glow rings (white, layered alpha) for depth
- Upload arrow: neon cyan #67E8F9 → sky blue #38BDF8
- Download arrow: hot pink #F472B6 → coral #FB923C
- Double-layer center orb (frosted + solid white)
- 4 cardinal accent sparks (cyan/indigo/pink/emerald)
- 4 diagonal mini sparks (light cyan/peach/violet/green)

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

app/src/main/AndroidManifest.xml

@@ -68,6 +68,12 @@
             </intent-filter>
         </receiver>
 
+        <!-- File watcher for ON_CHANGE sync pairs -->
+        <service
+            android:name=".worker.FileWatchService"
+            android:foregroundServiceType="dataSync"
+            android:exported="false" />
+
         <!-- Required on API 29+ so WorkManager can start a typed foreground service -->
         <service
             android:name="androidx.work.impl.foreground.SystemForegroundService"

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,46 +156,45 @@ 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()
-            factory.isNamespaceAware = true
-            val parser = factory.newPullParser()
-            parser.setInput(xml.reader())
+        val factory = XmlPullParserFactory.newInstance()
+        factory.isNamespaceAware = true
+        val parser = factory.newPullParser()
+        parser.setInput(xml.reader())
 
-            var href = ""; var isCollection = false; var contentLength = 0L
-            var lastModified: Instant = Instant.EPOCH; var etag: String? = null; var contentType: String? = null
-            var inResponse = false; var inProp = false
+        var href = ""; var isCollection = false; var contentLength = 0L
+        var lastModified: Instant = Instant.EPOCH; var etag: String? = null; var contentType: String? = null
+        var inResponse = false; var inProp = false
 
-            var eventType = parser.eventType
-            while (eventType != XmlPullParser.END_DOCUMENT) {
-                val tag = parser.name?.substringAfterLast(':')?.lowercase()
-                when (eventType) {
-                    XmlPullParser.START_TAG -> when (tag) {
-                        "response" -> { inResponse = true; href = ""; isCollection = false; contentLength = 0L; lastModified = Instant.EPOCH; etag = null; contentType = null }
-                        "prop" -> inProp = true
-                        "href" -> if (!inProp) href = parser.nextText().trim()
-                        "collection" -> if (inProp) isCollection = true
-                        "getcontentlength" -> if (inProp) contentLength = parser.nextText().trim().toLongOrNull() ?: 0L
-                        "getlastmodified" -> if (inProp) lastModified = parseHttpDate(parser.nextText().trim())
-                        "getetag" -> if (inProp) etag = parser.nextText().trim().trim('"')
-                        "getcontenttype" -> if (inProp) contentType = parser.nextText().trim()
-                    }
-                    XmlPullParser.END_TAG -> when (tag) {
-                        "prop" -> inProp = false
-                        "response" -> if (inResponse && href.isNotBlank()) {
-                            val name = href.trimEnd('/').substringAfterLast('/')
-                            val relPath = "$parentPath/$name".replace("//", "/")
-                            results.add(RemoteFile(relPath, name, isCollection, contentLength, lastModified, etag, contentType))
-                            inResponse = false
-                        }
+        var eventType = parser.eventType
+        while (eventType != XmlPullParser.END_DOCUMENT) {
+            val tag = parser.name?.substringAfterLast(':')?.lowercase()
+            when (eventType) {
+                XmlPullParser.START_TAG -> when (tag) {
+                    "response" -> { inResponse = true; href = ""; isCollection = false; contentLength = 0L; lastModified = Instant.EPOCH; etag = null; contentType = null }
+                    "prop" -> inProp = true
+                    "href" -> if (!inProp) href = parser.nextText().trim()
+                    "collection" -> if (inProp) isCollection = true
+                    "getcontentlength" -> if (inProp) contentLength = parser.nextText().trim().toLongOrNull() ?: 0L
+                    "getlastmodified" -> if (inProp) lastModified = parseHttpDate(parser.nextText().trim())
+                    "getetag" -> if (inProp) etag = parser.nextText().trim().trim('"')
+                    "getcontenttype" -> if (inProp) contentType = parser.nextText().trim()
+                }
+                XmlPullParser.END_TAG -> when (tag) {
+                    "prop" -> inProp = false
+                    "response" -> if (inResponse && href.isNotBlank()) {
+                        val rawName = href.trimEnd('/').substringAfterLast('/')
+                        val name = try { java.net.URLDecoder.decode(rawName, "UTF-8") } catch (_: Exception) { rawName }
+                        val relPath = "$parentPath/$name".replace("//", "/")
+                        results.add(RemoteFile(relPath, name, isCollection, contentLength, lastModified, etag, contentType))
+                        inResponse = false
                     }
                 }
-                eventType = parser.next()
             }
-        } catch (_: Exception) {}
-        return results.drop(1) // drop the parent folder itself
+            eventType = parser.next()
+        }
+        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/main/kotlin/com/syncflow/ui/addpair/AddPairViewModel.kt

@@ -1,5 +1,6 @@
 package com.syncflow.ui.addpair
 
+import android.content.Context
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
@@ -7,9 +8,10 @@ import com.syncflow.data.db.CloudAccountDao
 import com.syncflow.data.db.SyncPairDao
 import com.syncflow.data.db.entities.CloudAccountEntity
 import com.syncflow.data.db.entities.SyncPairEntity
-import com.syncflow.data.db.entities.toDomain
 import com.syncflow.domain.model.*
+import com.syncflow.worker.FileWatchService
 import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.flow.*
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -31,7 +33,7 @@ data class AddPairUiState(
     val scheduleType: ScheduleType = ScheduleType.INTERVAL,
     val intervalMinutes: Int = 30,
     val dailyTime: String = "02:00",
-    val weekdays: Int = 0b1111111,           // all 7 days by default
+    val weekdays: Int = 0b1111111,
     // ── Constraints ──────────────────────────────────────────────────────────
     val wifiOnly: Boolean = true,
     val wifiSsid: String = "",
@@ -57,6 +59,7 @@ data class AddPairUiState(
 class AddPairViewModel @Inject constructor(
     private val syncPairDao: SyncPairDao,
     private val accountDao: CloudAccountDao,
+    @ApplicationContext private val context: Context,
     savedState: SavedStateHandle,
 ) : ViewModel() {
 
@@ -147,7 +150,10 @@ class AddPairViewModel @Inject constructor(
                 )
                 if (editPairId == null) syncPairDao.insert(entity) else syncPairDao.update(entity)
             }
-                .onSuccess { _state.update { it.copy(done = true) } }
+                .onSuccess {
+                    if (s.scheduleType == ScheduleType.ON_CHANGE) FileWatchService.start(context)
+                    _state.update { it.copy(done = true) }
+                }
                 .onFailure { e -> _state.update { it.copy(isSaving = false, error = e.message) } }
         }
     }

app/src/main/kotlin/com/syncflow/ui/browser/RemoteBrowserDialog.kt

@@ -27,7 +27,7 @@ fun RemoteBrowserDialog(
     onDismiss: () -> Unit,
     vm: RemoteBrowserViewModel = hiltViewModel(),
 ) {
-    LaunchedEffect(accountId) { vm.init(accountId, initialPath) }
+    LaunchedEffect(accountId, initialPath) { vm.init(accountId, initialPath) }
 
     val state by vm.state.collectAsState()
 
@@ -81,6 +81,7 @@ fun RemoteBrowserDialog(
                         Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(8.dp)) {
                             Icon(Icons.Default.ErrorOutline, null, Modifier.size(48.dp), tint = MaterialTheme.colorScheme.error)
                             Text(state.error!!, color = MaterialTheme.colorScheme.error)
+                            FilledTonalButton(onClick = { vm.retry() }) { Text("Retry") }
                         }
                     }
                     state.entries.isEmpty() -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {

app/src/main/kotlin/com/syncflow/ui/browser/RemoteBrowserViewModel.kt

@@ -6,6 +6,7 @@ import com.syncflow.data.providers.ProviderFactory
 import com.syncflow.data.repository.AccountRepository
 import com.syncflow.domain.model.RemoteFile
 import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.update
@@ -30,15 +31,19 @@ class RemoteBrowserViewModel @Inject constructor(
     private val _state = MutableStateFlow(BrowserState())
     val state = _state.asStateFlow()
 
+    private var loadJob: Job? = null
+
     fun init(accountId: Long, startPath: String = "/") {
-        _state.update { it.copy(accountId = accountId, currentPath = startPath, pathStack = listOf(startPath)) }
-        loadPath(accountId, startPath)
+        loadJob?.cancel()
+        _state.value = BrowserState(accountId = accountId, currentPath = startPath, pathStack = listOf(startPath), isLoading = true)
+        loadJob = loadPath(accountId, startPath)
     }
 
     fun navigateTo(path: String) {
         val accountId = _state.value.accountId
-        _state.update { s -> s.copy(currentPath = path, pathStack = s.pathStack + path) }
-        loadPath(accountId, path)
+        loadJob?.cancel()
+        _state.update { s -> s.copy(currentPath = path, pathStack = s.pathStack + path, isLoading = true, entries = emptyList(), error = null) }
+        loadJob = loadPath(accountId, path)
     }
 
     fun navigateUp(): Boolean {
@@ -46,30 +51,36 @@ class RemoteBrowserViewModel @Inject constructor(
         if (stack.size <= 1) return false
         val newStack = stack.dropLast(1)
         val parent = newStack.last()
-        _state.update { it.copy(currentPath = parent, pathStack = newStack) }
-        loadPath(_state.value.accountId, parent)
+        loadJob?.cancel()
+        _state.update { it.copy(currentPath = parent, pathStack = newStack, isLoading = true, entries = emptyList(), error = null) }
+        loadJob = loadPath(_state.value.accountId, parent)
         return true
     }
 
-    private fun loadPath(accountId: Long, path: String) {
-        viewModelScope.launch {
-            _state.update { it.copy(isLoading = true, error = null) }
-            val account = accountRepository.getAccount(accountId)
-            if (account == null) {
-                _state.update { it.copy(isLoading = false, error = "Account not found") }
-                return@launch
-            }
-            val provider = runCatching { providerFactory.create(account) }.getOrElse { e ->
-                _state.update { it.copy(isLoading = false, error = e.message) }
-                return@launch
-            }
-            provider.listFiles(path)
-                .onSuccess { files ->
-                    _state.update { it.copy(isLoading = false, entries = files.sortedWith(compareBy({ !it.isDirectory }, { it.name.lowercase() }))) }
-                }
-                .onFailure { e ->
-                    _state.update { it.copy(isLoading = false, error = e.message ?: "Failed to list files") }
-                }
+    fun retry() {
+        val s = _state.value
+        if (s.accountId == -1L) return
+        loadJob?.cancel()
+        _state.update { it.copy(isLoading = true, error = null) }
+        loadJob = loadPath(s.accountId, s.currentPath)
+    }
+
+    private fun loadPath(accountId: Long, path: String): Job = viewModelScope.launch {
+        val account = accountRepository.getAccount(accountId)
+        if (account == null) {
+            _state.update { it.copy(isLoading = false, error = "Account not found") }
+            return@launch
         }
+        val provider = runCatching { providerFactory.create(account) }.getOrElse { e ->
+            _state.update { it.copy(isLoading = false, error = e.message ?: "Failed to create provider") }
+            return@launch
+        }
+        provider.listFiles(path)
+            .onSuccess { files ->
+                _state.update { it.copy(isLoading = false, entries = files.sortedWith(compareBy({ !it.isDirectory }, { it.name.lowercase() }))) }
+            }
+            .onFailure { e ->
+                _state.update { it.copy(isLoading = false, error = e.message ?: "Failed to list files") }
+            }
     }
 }

app/src/main/kotlin/com/syncflow/ui/home/HomeScreen.kt

@@ -1,9 +1,16 @@
 package com.syncflow.ui.home
 
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.infiniteRepeatable
+import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
 import androidx.compose.material.icons.outlined.*
@@ -11,11 +18,13 @@ import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.syncflow.data.db.entities.SyncPairEntity
 import com.syncflow.domain.model.SyncStatus
+import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
@@ -58,49 +67,117 @@ private fun SyncPairCard(
     onSync: () -> Unit,
     onToggle: () -> Unit,
 ) {
-    ElevatedCard(
-        modifier = Modifier.fillMaxWidth().clickable(onClick = onClick),
-        elevation = CardDefaults.elevatedCardElevation(defaultElevation = 2.dp),
+    val accentColor = pair.lastSyncResult.accentColor
+
+    Card(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick),
+        shape = RoundedCornerShape(16.dp),
+        border = BorderStroke(1.dp, MaterialTheme.colorScheme.outline),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
     ) {
-        Column(modifier = Modifier.padding(16.dp)) {
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                Column(modifier = Modifier.weight(1f)) {
-                    Text(pair.name, style = MaterialTheme.typography.titleMedium, fontWeight = FontWeight.SemiBold)
-                    Spacer(Modifier.height(2.dp))
-                    Text(
-                        pair.localPath.takeLast(40),
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
-                }
-                Switch(checked = pair.isEnabled, onCheckedChange = { onToggle() })
-            }
-            Spacer(Modifier.height(10.dp))
-            Row(
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.spacedBy(8.dp),
+        Row(modifier = Modifier.fillMaxWidth()) {
+            // Colored left accent bar
+            Box(
+                modifier = Modifier
+                    .width(3.dp)
+                    .height(IntrinsicSize.Min)
+                    .defaultMinSize(minHeight = 80.dp),
             ) {
-                StatusChip(pair.lastSyncResult)
-                if (pair.pendingConflicts > 0) {
-                    AssistChip(
-                        onClick = {},
-                        label = { Text("${pair.pendingConflicts} conflicts") },
-                        leadingIcon = { Icon(Icons.Default.Warning, null, Modifier.size(16.dp)) },
-                        colors = AssistChipDefaults.assistChipColors(
-                            containerColor = MaterialTheme.colorScheme.errorContainer,
-                        ),
+                Box(
+                    modifier = Modifier
+                        .fillMaxHeight()
+                        .width(3.dp),
+                ) {
+                    Surface(
+                        modifier = Modifier.fillMaxSize(),
+                        color = accentColor,
+                    ) {}
+                }
+            }
+
+            Column(modifier = Modifier.padding(start = 12.dp, top = 12.dp, end = 12.dp, bottom = 12.dp)) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    Column(modifier = Modifier.weight(1f)) {
+                        Text(
+                            pair.name,
+                            style = MaterialTheme.typography.titleMedium,
+                        )
+                        Spacer(Modifier.height(2.dp))
+                        val localShortName = pair.localPath.toDisplayPath()
+                        Text(
+                            localShortName,
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                        Spacer(Modifier.height(2.dp))
+                        Row(verticalAlignment = Alignment.CenterVertically) {
+                            Icon(
+                                Icons.Default.ArrowForward,
+                                contentDescription = null,
+                                modifier = Modifier.size(12.dp),
+                                tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                            )
+                            Spacer(Modifier.width(4.dp))
+                            Text(
+                                pair.remotePath,
+                                style = MaterialTheme.typography.bodySmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            )
+                        }
+                    }
+                    Switch(
+                        checked = pair.isEnabled,
+                        onCheckedChange = { onToggle() },
                     )
                 }
-                Spacer(Modifier.weight(1f))
-                pair.lastSyncAt?.let { at ->
-                    Text(
-                        at.formatRelative(),
-                        style = MaterialTheme.typography.labelSmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                Spacer(Modifier.height(8.dp))
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                ) {
+                    StatusPill(pair.lastSyncResult)
+                    if (pair.pendingConflicts > 0) {
+                        Surface(
+                            shape = RoundedCornerShape(50),
+                            color = MaterialTheme.colorScheme.errorContainer,
+                        ) {
+                            Row(
+                                modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
+                                verticalAlignment = Alignment.CenterVertically,
+                                horizontalArrangement = Arrangement.spacedBy(4.dp),
+                            ) {
+                                Icon(Icons.Default.Warning, null, Modifier.size(12.dp), tint = MaterialTheme.colorScheme.error)
+                                Text(
+                                    "${pair.pendingConflicts} conflicts",
+                                    style = MaterialTheme.typography.labelSmall,
+                                    color = MaterialTheme.colorScheme.error,
+                                )
+                            }
+                        }
+                    }
+                    Spacer(Modifier.weight(1f))
+                    pair.lastSyncAt?.let { at ->
+                        Text(
+                            at.toRelativeString(),
+                            style = MaterialTheme.typography.labelSmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+                    val syncRotation by rememberInfiniteTransition(label = "cardSyncSpin").animateFloat(
+                        initialValue = 0f, targetValue = 360f,
+                        animationSpec = infiniteRepeatable(tween(900, easing = LinearEasing)),
+                        label = "cardRotation",
                     )
-                }
-                FilledTonalIconButton(onClick = onSync, modifier = Modifier.size(36.dp)) {
-                    Icon(Icons.Default.Sync, "Sync now", modifier = Modifier.size(18.dp))
+                    FilledTonalIconButton(onClick = onSync, modifier = Modifier.size(36.dp)) {
+                        Icon(
+                            Icons.Default.Sync, "Sync now",
+                            modifier = Modifier.size(18.dp).graphicsLayer {
+                                if (pair.lastSyncResult == SyncStatus.SYNCING) rotationZ = syncRotation
+                            },
+                        )
+                    }
                 }
             }
         }
@@ -108,21 +185,38 @@ private fun SyncPairCard(
 }
 
 @Composable
-private fun StatusChip(status: SyncStatus) {
-    val (icon, label, color) = when (status) {
-        SyncStatus.SUCCESS -> Triple(Icons.Default.CheckCircle, "Synced", MaterialTheme.colorScheme.primaryContainer)
-        SyncStatus.SYNCING -> Triple(Icons.Default.Sync, "Syncing…", MaterialTheme.colorScheme.secondaryContainer)
-        SyncStatus.FAILED -> Triple(Icons.Default.Error, "Failed", MaterialTheme.colorScheme.errorContainer)
-        SyncStatus.CONFLICT -> Triple(Icons.Default.Warning, "Conflict", MaterialTheme.colorScheme.tertiaryContainer)
-        SyncStatus.PARTIAL -> Triple(Icons.Default.WarningAmber, "Partial", MaterialTheme.colorScheme.tertiaryContainer)
-        SyncStatus.IDLE -> Triple(Icons.Outlined.Circle, "Idle", MaterialTheme.colorScheme.surfaceVariant)
+private fun StatusPill(status: SyncStatus) {
+    val (icon, label) = when (status) {
+        SyncStatus.SUCCESS  -> Pair(Icons.Default.CheckCircle, "Synced")
+        SyncStatus.SYNCING  -> Pair(Icons.Default.Sync, "Syncing…")
+        SyncStatus.FAILED   -> Pair(Icons.Default.Error, "Failed")
+        SyncStatus.CONFLICT -> Pair(Icons.Default.Warning, "Conflict")
+        SyncStatus.PARTIAL  -> Pair(Icons.Default.WarningAmber, "Partial")
+        SyncStatus.IDLE     -> Pair(Icons.Outlined.Circle, "Idle")
     }
-    AssistChip(
-        onClick = {},
-        label = { Text(label) },
-        leadingIcon = { Icon(icon, null, Modifier.size(16.dp)) },
-        colors = AssistChipDefaults.assistChipColors(containerColor = color),
+    val containerColor = status.accentColor
+    val rotation by rememberInfiniteTransition(label = "syncSpin").animateFloat(
+        initialValue = 0f, targetValue = 360f,
+        animationSpec = infiniteRepeatable(tween(1000, easing = LinearEasing)),
+        label = "rotation",
     )
+    Surface(
+        shape = RoundedCornerShape(50),
+        color = containerColor.copy(alpha = 0.15f),
+    ) {
+        Row(
+            modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(4.dp),
+        ) {
+            Icon(
+                icon, null,
+                Modifier.size(12.dp).graphicsLayer { if (status == SyncStatus.SYNCING) rotationZ = rotation },
+                tint = containerColor,
+            )
+            Text(label, style = MaterialTheme.typography.labelSmall, color = containerColor)
+        }
+    }
 }
 
 @Composable
@@ -132,15 +226,49 @@ private fun EmptyState(modifier: Modifier = Modifier, onAdd: () -> Unit) {
         horizontalAlignment = Alignment.CenterHorizontally,
         verticalArrangement = Arrangement.Center,
     ) {
-        Icon(Icons.Outlined.CloudSync, null, modifier = Modifier.size(80.dp), tint = MaterialTheme.colorScheme.primary)
+        Icon(
+            Icons.Outlined.CloudSync,
+            null,
+            modifier = Modifier.size(100.dp),
+            tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.4f),
+        )
         Spacer(Modifier.height(16.dp))
-        Text("No sync pairs yet", style = MaterialTheme.typography.titleLarge, fontWeight = FontWeight.Medium)
+        Text("No sync pairs yet", style = MaterialTheme.typography.titleLarge)
         Spacer(Modifier.height(8.dp))
-        Text("Tap + to create your first sync", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        Text(
+            "Tap + to create your first sync",
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
         Spacer(Modifier.height(24.dp))
-        Button(onClick = onAdd) { Text("Add Sync Pair") }
+        FilledTonalButton(onClick = onAdd) { Text("Add Sync Pair") }
     }
 }
 
-private val fmt = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT)
-private fun Instant.formatRelative(): String = fmt.format(atZone(ZoneId.systemDefault()))
+private val SyncStatus.accentColor: Color
+    @Composable get() = when (this) {
+        SyncStatus.SUCCESS              -> MaterialTheme.colorScheme.primary
+        SyncStatus.SYNCING              -> MaterialTheme.colorScheme.secondary
+        SyncStatus.FAILED               -> MaterialTheme.colorScheme.error
+        SyncStatus.CONFLICT,
+        SyncStatus.PARTIAL              -> MaterialTheme.colorScheme.tertiary
+        SyncStatus.IDLE                 -> MaterialTheme.colorScheme.outline
+    }
+
+private fun String.toDisplayPath(): String {
+    // For SAF content:// URIs, decode the last path segment (e.g. primary%3ASyncFlowTest → SyncFlowTest)
+    val decoded = java.net.URLDecoder.decode(this, "UTF-8")
+    return decoded.trimEnd('/').substringAfterLast('/').substringAfterLast(':').ifEmpty { decoded }
+}
+
+private fun Instant.toRelativeString(): String {
+    val diff = Duration.between(this, Instant.now()).abs()
+    return when {
+        diff.toMinutes() < 1  -> "Just now"
+        diff.toMinutes() < 60 -> "${diff.toMinutes()} min ago"
+        diff.toHours() < 24   -> "${diff.toHours()} hr ago"
+        diff.toDays() == 1L   -> "Yesterday"
+        else -> DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)
+            .format(atZone(ZoneId.systemDefault()))
+    }
+}

app/src/main/kotlin/com/syncflow/ui/home/HomeViewModel.kt

@@ -1,13 +1,17 @@
 package com.syncflow.ui.home
 
+import android.content.Context
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.WorkManager
 import com.syncflow.data.db.SyncPairDao
 import com.syncflow.data.db.entities.SyncPairEntity
 import com.syncflow.domain.model.ScheduleType
+import com.syncflow.worker.FileWatchService
 import com.syncflow.worker.SyncWorker
 import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
@@ -17,6 +21,7 @@ import javax.inject.Inject
 class HomeViewModel @Inject constructor(
     private val syncPairDao: SyncPairDao,
     private val workManager: WorkManager,
+    @ApplicationContext private val context: Context,
 ) : ViewModel() {
 
     val syncPairs = syncPairDao.observeAll()
@@ -29,21 +34,28 @@ class HomeViewModel @Inject constructor(
 
     fun toggleEnabled(pair: SyncPairEntity) {
         viewModelScope.launch {
-            syncPairDao.update(pair.copy(isEnabled = !pair.isEnabled))
-            if (!pair.isEnabled && pair.scheduleType != ScheduleType.MANUAL) {
-                val req = SyncWorker.buildPeriodicRequest(
-                    pair.id,
-                    pair.scheduleIntervalMinutes.toLong().coerceAtLeast(15),
-                    pair.wifiOnly,
-                    pair.chargingOnly,
-                )
-                workManager.enqueueUniquePeriodicWork(
-                    "periodic_${pair.id}",
-                    androidx.work.ExistingPeriodicWorkPolicy.UPDATE,
-                    req,
-                )
+            val nowEnabled = !pair.isEnabled
+            syncPairDao.update(pair.copy(isEnabled = nowEnabled))
+            if (nowEnabled) {
+                when (pair.scheduleType) {
+                    ScheduleType.ON_CHANGE -> FileWatchService.start(context)
+                    ScheduleType.MANUAL -> { /* nothing */ }
+                    else -> {
+                        val req = SyncWorker.buildPeriodicRequest(
+                            pair.id,
+                            pair.scheduleIntervalMinutes.toLong().coerceAtLeast(15),
+                            pair.wifiOnly,
+                            pair.chargingOnly,
+                        )
+                        workManager.enqueueUniquePeriodicWork("periodic_${pair.id}", ExistingPeriodicWorkPolicy.UPDATE, req)
+                    }
+                }
             } else {
                 workManager.cancelAllWorkByTag("sync_${pair.id}")
+                // Refresh watcher (it will stop itself if no ON_CHANGE pairs remain)
+                if (pair.scheduleType == ScheduleType.ON_CHANGE) {
+                    FileWatchService.start(context)
+                }
             }
         }
     }

app/src/main/kotlin/com/syncflow/ui/main/MainShell.kt

@@ -6,8 +6,15 @@ import androidx.compose.animation.fadeOut
 import androidx.compose.animation.scaleIn
 import androidx.compose.animation.scaleOut
 import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.statusBars
+import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.pager.HorizontalPager
 import androidx.compose.foundation.pager.rememberPagerState
 import androidx.compose.material.icons.Icons
@@ -19,8 +26,11 @@ import androidx.compose.material.icons.outlined.Sync
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import com.syncflow.R
 import com.syncflow.ui.home.HomeScreen
 import com.syncflow.ui.settings.SettingsScreen
 import kotlinx.coroutines.launch
@@ -38,11 +48,26 @@ fun MainShell(
 
     Scaffold(
         topBar = {
-            TopAppBar(
-                title = { Text("SyncFlow", fontWeight = FontWeight.Bold) },
-                colors = TopAppBarDefaults.topAppBarColors(
+            CenterAlignedTopAppBar(
+                title = {
+                    Row(verticalAlignment = Alignment.CenterVertically) {
+                        Icon(
+                            painter = painterResource(id = R.drawable.ic_sync),
+                            contentDescription = null,
+                            modifier = Modifier.size(20.dp),
+                            tint = MaterialTheme.colorScheme.primary,
+                        )
+                        Spacer(Modifier.width(8.dp))
+                        Text(
+                            "SyncFlow",
+                            style = MaterialTheme.typography.titleLarge,
+                        )
+                    }
+                },
+                colors = TopAppBarDefaults.centerAlignedTopAppBarColors(
                     containerColor = MaterialTheme.colorScheme.surface,
                 ),
+                modifier = Modifier.windowInsetsPadding(WindowInsets.statusBars),
             )
         },
         bottomBar = {
@@ -81,6 +106,8 @@ fun MainShell(
                     text = { Text("Add Sync") },
                     icon = { Icon(Icons.Default.Add, null) },
                     onClick = onAddPair,
+                    containerColor = MaterialTheme.colorScheme.primary,
+                    contentColor = MaterialTheme.colorScheme.onPrimary,
                 )
             }
         },

app/src/main/kotlin/com/syncflow/ui/pairdetail/PairDetailScreen.kt

@@ -1,18 +1,32 @@
 package com.syncflow.ui.pairdetail
 
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.infiniteRepeatable
+import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.tween
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
+import androidx.compose.material.icons.outlined.Circle
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.syncflow.data.db.entities.SyncEventEntity
+import com.syncflow.data.db.entities.SyncPairEntity
 import com.syncflow.domain.model.SyncEventType
+import com.syncflow.domain.model.SyncStatus
+import java.time.Duration
+import java.time.Instant
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import java.time.format.FormatStyle
@@ -36,7 +50,10 @@ fun PairDetailScreen(
             title = { Text("Delete sync pair?") },
             text = { Text("This removes the pair and all sync history. Files are NOT deleted.") },
             confirmButton = {
-                TextButton(onClick = { vm.delete(); onBack() }, colors = ButtonDefaults.textButtonColors(contentColor = MaterialTheme.colorScheme.error)) {
+                TextButton(
+                    onClick = { vm.delete(); onBack() },
+                    colors = ButtonDefaults.textButtonColors(contentColor = MaterialTheme.colorScheme.error),
+                ) {
                     Text("Delete")
                 }
             },
@@ -60,8 +77,12 @@ fun PairDetailScreen(
         LazyColumn(
             modifier = Modifier.padding(padding),
             contentPadding = PaddingValues(16.dp),
-            verticalArrangement = Arrangement.spacedBy(8.dp),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
         ) {
+            item {
+                pair?.let { p -> StatusBanner(p) }
+            }
+
             item {
                 pair?.let { p ->
                     InfoCard(p.localPath, p.remotePath, p.syncDirection.name, p.scheduleType.name)
@@ -85,8 +106,22 @@ fun PairDetailScreen(
             }
 
             item {
-                Text("Activity", style = MaterialTheme.typography.titleSmall, color = MaterialTheme.colorScheme.primary)
-                HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp))
+                Row(
+                    verticalAlignment = Alignment.CenterVertically,
+                    modifier = Modifier.padding(top = 4.dp),
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .width(3.dp)
+                            .height(16.dp)
+                            .clip(RoundedCornerShape(2.dp)),
+                    ) {
+                        Surface(color = MaterialTheme.colorScheme.primary, modifier = Modifier.fillMaxSize()) {}
+                    }
+                    Spacer(Modifier.width(8.dp))
+                    Text("Activity", style = MaterialTheme.typography.titleSmall)
+                }
+                HorizontalDivider(modifier = Modifier.padding(top = 4.dp))
             }
 
             if (events.isEmpty()) {
@@ -105,24 +140,94 @@ fun PairDetailScreen(
 }
 
 @Composable
-private fun InfoCard(localPath: String, remotePath: String, direction: String, schedule: String) {
-    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
-        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) {
-            InfoRow(Icons.Default.PhoneAndroid, "Local", localPath)
-            InfoRow(Icons.Default.Cloud, "Remote", remotePath)
-            InfoRow(Icons.Default.SwapHoriz, "Direction", direction)
-            InfoRow(Icons.Default.Schedule, "Schedule", schedule)
+private fun StatusBanner(pair: SyncPairEntity) {
+    val (icon, label, containerColor) = when (pair.lastSyncResult) {
+        SyncStatus.SUCCESS  -> Triple(Icons.Default.CheckCircle, "Synced",    MaterialTheme.colorScheme.primaryContainer)
+        SyncStatus.SYNCING  -> Triple(Icons.Default.Sync,        "Syncing…",  MaterialTheme.colorScheme.secondaryContainer)
+        SyncStatus.FAILED   -> Triple(Icons.Default.Error,       "Failed",    MaterialTheme.colorScheme.errorContainer)
+        SyncStatus.CONFLICT -> Triple(Icons.Default.Warning,     "Conflict",  MaterialTheme.colorScheme.tertiaryContainer)
+        SyncStatus.PARTIAL  -> Triple(Icons.Default.WarningAmber,"Partial",   MaterialTheme.colorScheme.tertiaryContainer)
+        SyncStatus.IDLE     -> Triple(Icons.Outlined.Circle,     "Idle",      MaterialTheme.colorScheme.surfaceVariant)
+    }
+    val rotation by rememberInfiniteTransition(label = "bannerSpin").animateFloat(
+        initialValue = 0f, targetValue = 360f,
+        animationSpec = infiniteRepeatable(tween(1000, easing = LinearEasing)),
+        label = "bannerRotation",
+    )
+    Surface(
+        color = containerColor,
+        shape = RoundedCornerShape(16.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Row(
+            modifier = Modifier.padding(16.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Icon(
+                icon, null,
+                modifier = Modifier.size(40.dp).graphicsLayer {
+                    if (pair.lastSyncResult == SyncStatus.SYNCING) rotationZ = rotation
+                },
+            )
+            Spacer(Modifier.width(16.dp))
+            Column {
+                Text(label, style = MaterialTheme.typography.titleMedium)
+                pair.lastSyncAt?.let {
+                    Text(it.toRelativeString(), style = MaterialTheme.typography.bodySmall)
+                }
+            }
         }
     }
 }
 
 @Composable
-private fun InfoRow(icon: androidx.compose.ui.graphics.vector.ImageVector, label: String, value: String) {
-    Row(verticalAlignment = Alignment.CenterVertically) {
-        Icon(icon, null, Modifier.size(16.dp), tint = MaterialTheme.colorScheme.primary)
+private fun InfoCard(localPath: String, remotePath: String, direction: String, schedule: String) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(16.dp),
+        border = androidx.compose.foundation.BorderStroke(1.dp, MaterialTheme.colorScheme.outline),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+    ) {
+        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            InfoRow(Icons.Default.PhoneAndroid, "Local", localPath.toDisplayPath())
+            HorizontalDivider(color = MaterialTheme.colorScheme.outline.copy(alpha = 0.5f))
+            InfoRow(Icons.Default.Cloud, "Remote", remotePath)
+            HorizontalDivider(color = MaterialTheme.colorScheme.outline.copy(alpha = 0.5f))
+            Row {
+                InfoRow(Icons.Default.SwapHoriz, "Direction", direction, modifier = Modifier.weight(1f))
+                InfoRow(Icons.Default.Schedule, "Schedule", schedule, modifier = Modifier.weight(1f))
+            }
+        }
+    }
+}
+
+@Composable
+private fun InfoRow(
+    icon: androidx.compose.ui.graphics.vector.ImageVector,
+    label: String,
+    value: String,
+    modifier: Modifier = Modifier,
+) {
+    Row(verticalAlignment = Alignment.CenterVertically, modifier = modifier) {
+        Surface(
+            shape = RoundedCornerShape(8.dp),
+            color = MaterialTheme.colorScheme.primaryContainer,
+            modifier = Modifier.size(28.dp),
+        ) {
+            Box(contentAlignment = Alignment.Center) {
+                Icon(
+                    icon,
+                    null,
+                    Modifier.size(16.dp),
+                    tint = MaterialTheme.colorScheme.onPrimaryContainer,
+                )
+            }
+        }
         Spacer(Modifier.width(8.dp))
-        Text("$label: ", style = MaterialTheme.typography.labelMedium)
-        Text(value, style = MaterialTheme.typography.bodySmall, modifier = Modifier.weight(1f))
+        Column {
+            Text(label, style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+            Text(value, style = MaterialTheme.typography.bodySmall)
+        }
     }
 }
 
@@ -130,38 +235,65 @@ private fun InfoRow(icon: androidx.compose.ui.graphics.vector.ImageVector, label
 private fun EventRow(event: SyncEventEntity) {
     val fmt = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)
     val zone = ZoneId.systemDefault()
-    val (icon, tint) = eventIcon(event.eventType)
+    val dotColor = eventColor(event.eventType)
     Row(
-        modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
+        modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
         verticalAlignment = Alignment.CenterVertically,
     ) {
-        Icon(icon, null, Modifier.size(16.dp), tint = tint)
-        Spacer(Modifier.width(8.dp))
+        // Colored dot indicator
+        Surface(
+            shape = RoundedCornerShape(50),
+            color = dotColor,
+            modifier = Modifier.size(8.dp),
+        ) {}
+        Spacer(Modifier.width(10.dp))
         Column(modifier = Modifier.weight(1f)) {
-            Text(event.filePath ?: event.message ?: event.eventType.name, style = MaterialTheme.typography.bodySmall)
+            Text(
+                event.filePath ?: event.message ?: event.eventType.name,
+                style = MaterialTheme.typography.bodySmall,
+            )
             event.message?.takeIf { event.filePath != null }?.let {
-                Text(it, style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                Text(
+                    it,
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
             }
         }
-        Text(fmt.format(event.timestamp.atZone(zone)), style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+        Text(
+            fmt.format(event.timestamp.atZone(zone)),
+            style = MaterialTheme.typography.labelSmall,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
     }
 }
 
 @Composable
-private fun eventIcon(type: SyncEventType): Pair<androidx.compose.ui.graphics.vector.ImageVector, androidx.compose.ui.graphics.Color> {
-    val green = MaterialTheme.colorScheme.primary
-    val red = MaterialTheme.colorScheme.error
-    val orange = MaterialTheme.colorScheme.tertiary
-    val grey = MaterialTheme.colorScheme.onSurfaceVariant
-    return when (type) {
-        SyncEventType.SYNC_STARTED -> Pair(Icons.Default.PlayArrow, green)
-        SyncEventType.SYNC_COMPLETED -> Pair(Icons.Default.CheckCircle, green)
-        SyncEventType.SYNC_FAILED -> Pair(Icons.Default.Error, red)
-        SyncEventType.FILE_UPLOADED -> Pair(Icons.Default.Upload, green)
-        SyncEventType.FILE_DOWNLOADED -> Pair(Icons.Default.Download, green)
-        SyncEventType.FILE_DELETED -> Pair(Icons.Default.Delete, orange)
-        SyncEventType.FILE_SKIPPED -> Pair(Icons.Default.SkipNext, grey)
-        SyncEventType.CONFLICT_DETECTED -> Pair(Icons.Default.Warning, orange)
-        SyncEventType.CONFLICT_RESOLVED -> Pair(Icons.Default.CheckCircle, green)
+private fun eventColor(type: SyncEventType): Color = when (type) {
+    SyncEventType.SYNC_STARTED     -> MaterialTheme.colorScheme.primary
+    SyncEventType.SYNC_COMPLETED   -> MaterialTheme.colorScheme.primary
+    SyncEventType.SYNC_FAILED      -> MaterialTheme.colorScheme.error
+    SyncEventType.FILE_UPLOADED    -> MaterialTheme.colorScheme.secondary
+    SyncEventType.FILE_DOWNLOADED  -> MaterialTheme.colorScheme.secondary
+    SyncEventType.FILE_DELETED     -> MaterialTheme.colorScheme.tertiary
+    SyncEventType.FILE_SKIPPED     -> MaterialTheme.colorScheme.onSurfaceVariant
+    SyncEventType.CONFLICT_DETECTED -> MaterialTheme.colorScheme.tertiary
+    SyncEventType.CONFLICT_RESOLVED -> MaterialTheme.colorScheme.primary
+}
+
+private fun String.toDisplayPath(): String {
+    val decoded = java.net.URLDecoder.decode(this, "UTF-8")
+    return decoded.trimEnd('/').substringAfterLast('/').substringAfterLast(':').ifEmpty { decoded }
+}
+
+private fun Instant.toRelativeString(): String {
+    val diff = Duration.between(this, Instant.now()).abs()
+    return when {
+        diff.toMinutes() < 1  -> "Just now"
+        diff.toMinutes() < 60 -> "${diff.toMinutes()} min ago"
+        diff.toHours() < 24   -> "${diff.toHours()} hr ago"
+        diff.toDays() == 1L   -> "Yesterday"
+        else -> DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)
+            .format(atZone(ZoneId.systemDefault()))
     }
 }

app/src/main/kotlin/com/syncflow/ui/settings/SettingsScreen.kt

@@ -1,14 +1,17 @@
 package com.syncflow.ui.settings
 
+import androidx.compose.foundation.BorderStroke
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.*
 import androidx.compose.material3.*
 import androidx.compose.runtime.*
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.syncflow.data.db.entities.CloudAccountEntity
@@ -45,15 +48,18 @@ fun SettingsScreen(
         verticalArrangement = Arrangement.spacedBy(8.dp),
     ) {
         item {
-            Row(verticalAlignment = Alignment.CenterVertically) {
-                Text("Cloud Accounts", style = MaterialTheme.typography.titleMedium, modifier = Modifier.weight(1f))
+            SectionHeader(title = "Cloud Accounts")
+            Spacer(Modifier.height(4.dp))
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.End,
+            ) {
                 FilledTonalButton(onClick = onAddAccount) {
                     Icon(Icons.Default.Add, null, Modifier.size(18.dp))
                     Spacer(Modifier.width(6.dp))
                     Text("Add Account")
                 }
             }
-            HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp))
         }
 
         if (accounts.isEmpty()) {
@@ -63,9 +69,22 @@ fun SettingsScreen(
                     horizontalAlignment = Alignment.CenterHorizontally,
                     verticalArrangement = Arrangement.spacedBy(8.dp),
                 ) {
-                    Icon(Icons.Default.CloudOff, null, Modifier.size(48.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
-                    Text("No accounts yet", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant)
-                    Text("Add a cloud account to start syncing", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                    Icon(
+                        Icons.Default.CloudOff,
+                        null,
+                        Modifier.size(48.dp),
+                        tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f),
+                    )
+                    Text(
+                        "No accounts yet",
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                    Text(
+                        "Add a cloud account to start syncing",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
                     OutlinedButton(onClick = onAddAccount) {
                         Icon(Icons.Default.Add, null, Modifier.size(16.dp))
                         Spacer(Modifier.width(6.dp))
@@ -80,40 +99,102 @@ fun SettingsScreen(
         }
 
         item {
-            Spacer(Modifier.height(16.dp))
-            Text("Security", style = MaterialTheme.typography.titleMedium)
-            HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp))
-            Row(
-                modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
-                verticalAlignment = Alignment.CenterVertically,
+            Spacer(Modifier.height(8.dp))
+            SectionHeader(title = "Security")
+            Spacer(Modifier.height(4.dp))
+            Card(
+                modifier = Modifier.fillMaxWidth(),
+                shape = RoundedCornerShape(16.dp),
+                border = BorderStroke(1.dp, MaterialTheme.colorScheme.outline),
+                colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
             ) {
-                Column(modifier = Modifier.weight(1f)) {
-                    Text("Biometric Lock", style = MaterialTheme.typography.bodyMedium)
-                    Text(
-                        "Require biometrics when returning to app",
-                        style = MaterialTheme.typography.bodySmall,
-                        color = MaterialTheme.colorScheme.onSurfaceVariant,
-                    )
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(16.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Column(modifier = Modifier.weight(1f)) {
+                        Text("Biometric Lock", style = MaterialTheme.typography.bodyMedium)
+                        Text(
+                            "Require biometrics when returning to app",
+                            style = MaterialTheme.typography.bodySmall,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+                    Switch(checked = biometricEnabled, onCheckedChange = { vm.setBiometricLock(it) })
                 }
-                Switch(checked = biometricEnabled, onCheckedChange = { vm.setBiometricLock(it) })
             }
         }
 
         item {
-            Spacer(Modifier.height(16.dp))
-            Text("About", style = MaterialTheme.typography.titleMedium)
-            HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp))
-            Text("SyncFlow v${com.syncflow.BuildConfig.VERSION_NAME} — Free, no subscription.", style = MaterialTheme.typography.bodySmall)
-            Text("Open source. No ads. No tracking.", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+            Spacer(Modifier.height(8.dp))
+            SectionHeader(title = "About")
+            Spacer(Modifier.height(4.dp))
+            Card(
+                modifier = Modifier.fillMaxWidth(),
+                shape = RoundedCornerShape(16.dp),
+                border = BorderStroke(1.dp, MaterialTheme.colorScheme.outline),
+                colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+            ) {
+                Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) {
+                    Text(
+                        "SyncFlow v${com.syncflow.BuildConfig.VERSION_NAME} — Free, no subscription.",
+                        style = MaterialTheme.typography.bodySmall,
+                    )
+                    Text(
+                        "Open source. No ads. No tracking.",
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
         }
     }
 }
 
+@Composable
+private fun SectionHeader(title: String) {
+    Row(verticalAlignment = Alignment.CenterVertically) {
+        Box(
+            modifier = Modifier
+                .width(3.dp)
+                .height(16.dp)
+                .clip(RoundedCornerShape(2.dp)),
+        ) {
+            Surface(color = MaterialTheme.colorScheme.primary, modifier = Modifier.fillMaxSize()) {}
+        }
+        Spacer(Modifier.width(8.dp))
+        Text(
+            title,
+            style = MaterialTheme.typography.titleMedium,
+            color = MaterialTheme.colorScheme.onBackground,
+        )
+    }
+}
+
 @Composable
 private fun AccountCard(acct: CloudAccountEntity, onDelete: () -> Unit) {
-    ElevatedCard(modifier = Modifier.fillMaxWidth()) {
+    Card(
+        modifier = Modifier.fillMaxWidth(),
+        shape = RoundedCornerShape(16.dp),
+        border = BorderStroke(1.dp, MaterialTheme.colorScheme.outline),
+        colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.surface),
+    ) {
         Row(modifier = Modifier.padding(12.dp), verticalAlignment = Alignment.CenterVertically) {
-            Icon(providerIcon(acct.providerType), null, Modifier.size(32.dp), tint = MaterialTheme.colorScheme.primary)
+            // Icon with primaryContainer background
+            Surface(
+                shape = RoundedCornerShape(12.dp),
+                color = MaterialTheme.colorScheme.primaryContainer,
+                modifier = Modifier.size(40.dp),
+            ) {
+                Box(contentAlignment = Alignment.Center) {
+                    Icon(
+                        providerIcon(acct.providerType),
+                        null,
+                        Modifier.size(22.dp),
+                        tint = MaterialTheme.colorScheme.onPrimaryContainer,
+                    )
+                }
+            }
             Spacer(Modifier.width(12.dp))
             Column(modifier = Modifier.weight(1f)) {
                 Text(acct.displayName, style = MaterialTheme.typography.bodyMedium)
@@ -138,22 +219,22 @@ private fun AccountCard(acct: CloudAccountEntity, onDelete: () -> Unit) {
 
 private fun providerIcon(type: ProviderType) = when (type) {
     ProviderType.GOOGLE_DRIVE -> Icons.Default.Cloud
-    ProviderType.DROPBOX -> Icons.Default.CloudQueue
-    ProviderType.ONEDRIVE -> Icons.Default.CloudDone
-    ProviderType.WEBDAV -> Icons.Default.Storage
-    ProviderType.SFTP -> Icons.Default.Terminal
-    ProviderType.NEXTCLOUD -> Icons.Default.CloudCircle
-    ProviderType.OWNCLOUD -> Icons.Default.CloudCircle
-    ProviderType.SFTPGO -> Icons.Default.Storage
+    ProviderType.DROPBOX      -> Icons.Default.CloudQueue
+    ProviderType.ONEDRIVE     -> Icons.Default.CloudDone
+    ProviderType.WEBDAV       -> Icons.Default.Storage
+    ProviderType.SFTP         -> Icons.Default.Terminal
+    ProviderType.NEXTCLOUD    -> Icons.Default.CloudCircle
+    ProviderType.OWNCLOUD     -> Icons.Default.CloudCircle
+    ProviderType.SFTPGO       -> Icons.Default.Storage
 }
 
 private fun friendlyProviderName(type: ProviderType) = when (type) {
     ProviderType.GOOGLE_DRIVE -> "Google Drive"
-    ProviderType.DROPBOX -> "Dropbox"
-    ProviderType.ONEDRIVE -> "OneDrive"
-    ProviderType.WEBDAV -> "WebDAV"
-    ProviderType.SFTP -> "SFTP"
-    ProviderType.NEXTCLOUD -> "Nextcloud"
-    ProviderType.OWNCLOUD -> "ownCloud"
-    ProviderType.SFTPGO -> "SFTPGo"
+    ProviderType.DROPBOX      -> "Dropbox"
+    ProviderType.ONEDRIVE     -> "OneDrive"
+    ProviderType.WEBDAV       -> "WebDAV"
+    ProviderType.SFTP         -> "SFTP"
+    ProviderType.NEXTCLOUD    -> "Nextcloud"
+    ProviderType.OWNCLOUD     -> "ownCloud"
+    ProviderType.SFTPGO       -> "SFTPGo"
 }

app/src/main/kotlin/com/syncflow/ui/theme/Color.kt

@@ -2,8 +2,27 @@ package com.syncflow.ui.theme
 
 import androidx.compose.ui.graphics.Color
 
-val SyncBlue = Color(0xFF2196F3)
-val SyncGreen = Color(0xFF4CAF50)
-val SyncOrange = Color(0xFFFF9800)
-val SyncRed = Color(0xFFF44336)
-val SyncPurple = Color(0xFF9C27B0)
+// Primary — indigo
+val Indigo600  = Color(0xFF4F46E5)
+val Indigo900  = Color(0xFF312E81)
+val Indigo100  = Color(0xFFE0E7FF)
+val Indigo50   = Color(0xFFEEF2FF)
+
+// Secondary — teal
+val Teal600    = Color(0xFF0D9488)
+val Teal100    = Color(0xFFCCFBF1)
+
+// Tertiary — amber
+val Amber500   = Color(0xFFF59E0B)
+val Amber100   = Color(0xFFFEF3C7)
+
+// Neutrals
+val Slate50    = Color(0xFFF8FAFC)
+val Slate100   = Color(0xFFF1F5F9)
+val Slate200   = Color(0xFFE2E8F0)
+val Slate600   = Color(0xFF475569)
+val Slate900   = Color(0xFF0F172A)
+
+// Semantic
+val GreenSuccess = Color(0xFF16A34A)
+val RedError     = Color(0xFFDC2626)

app/src/main/kotlin/com/syncflow/ui/theme/Theme.kt

@@ -1,50 +1,77 @@
 package com.syncflow.ui.theme
 
 import android.app.Activity
-import android.os.Build
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.SideEffect
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
 import androidx.core.view.WindowCompat
 
 private val LightColors = lightColorScheme(
-    primary = SyncBlue,
-    onPrimary = androidx.compose.ui.graphics.Color.White,
-    secondary = SyncGreen,
-    tertiary = SyncPurple,
+    primary            = Indigo600,
+    onPrimary          = Color.White,
+    primaryContainer   = Indigo100,
+    onPrimaryContainer = Indigo900,
+    secondary          = Teal600,
+    onSecondary        = Color.White,
+    secondaryContainer = Teal100,
+    tertiary           = Amber500,
+    tertiaryContainer  = Amber100,
+    background         = Slate50,
+    surface            = Color.White,
+    surfaceVariant     = Slate100,
+    onSurfaceVariant   = Slate600,
+    error              = RedError,
+    errorContainer     = Color(0xFFFEE2E2),
+    outline            = Slate200,
 )
 
 private val DarkColors = darkColorScheme(
-    primary = SyncBlue,
-    secondary = SyncGreen,
-    tertiary = SyncPurple,
+    primary            = Color(0xFF818CF8),
+    onPrimary          = Indigo900,
+    primaryContainer   = Color(0xFF3730A3),
+    onPrimaryContainer = Indigo100,
+    secondary          = Color(0xFF2DD4BF),
+    onSecondary        = Color(0xFF003731),
+    secondaryContainer = Color(0xFF00504A),
+    tertiary           = Amber500,
+    tertiaryContainer  = Color(0xFF92400E),
+    background         = Color(0xFF0F0F1A),
+    surface            = Color(0xFF1A1A2E),
+    surfaceVariant     = Color(0xFF252538),
+    onSurfaceVariant   = Color(0xFF94A3B8),
+    error              = Color(0xFFF87171),
+    errorContainer     = Color(0xFF7F1D1D),
+    outline            = Color(0xFF334155),
+)
+
+private val AppTypography = Typography(
+    titleLarge  = TextStyle(fontWeight = FontWeight.Bold,     fontSize = 22.sp, letterSpacing = (-0.5).sp),
+    titleMedium = TextStyle(fontWeight = FontWeight.SemiBold, fontSize = 16.sp, letterSpacing = (-0.25).sp),
+    titleSmall  = TextStyle(fontWeight = FontWeight.SemiBold, fontSize = 14.sp, letterSpacing = 0.sp),
+    labelMedium = TextStyle(fontWeight = FontWeight.Medium,   fontSize = 12.sp, letterSpacing = 0.1.sp),
+    labelSmall  = TextStyle(fontWeight = FontWeight.Medium,   fontSize = 11.sp, letterSpacing = 0.1.sp),
 )
 
 @Composable
 fun SyncFlowTheme(
     darkTheme: Boolean = isSystemInDarkTheme(),
-    dynamicColor: Boolean = true,
     content: @Composable () -> Unit,
 ) {
-    val colorScheme = when {
-        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
-            val ctx = LocalContext.current
-            if (darkTheme) dynamicDarkColorScheme(ctx) else dynamicLightColorScheme(ctx)
-        }
-        darkTheme -> DarkColors
-        else -> LightColors
-    }
+    val colorScheme = if (darkTheme) DarkColors else LightColors
     val view = LocalView.current
     if (!view.isInEditMode) {
         SideEffect {
             val window = (view.context as Activity).window
-            window.statusBarColor = colorScheme.primary.toArgb()
+            WindowCompat.setDecorFitsSystemWindows(window, false)
+            window.statusBarColor = android.graphics.Color.TRANSPARENT
             WindowCompat.getInsetsController(window, view).isAppearanceLightStatusBars = !darkTheme
         }
     }
-    MaterialTheme(colorScheme = colorScheme, typography = Typography(), content = content)
+    MaterialTheme(colorScheme = colorScheme, typography = AppTypography, content = content)
 }

app/src/main/kotlin/com/syncflow/worker/BootReceiver.kt

@@ -3,6 +3,7 @@ package com.syncflow.worker
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.WorkManager
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.CoroutineScope
@@ -22,17 +23,24 @@ class BootReceiver : BroadcastReceiver() {
         val pending = goAsync()
         CoroutineScope(Dispatchers.IO).launch {
             try {
-                syncPairDao.getEnabled()
-                    .filter { it.scheduleType != ScheduleType.MANUAL && it.scheduleType != ScheduleType.ON_CHANGE }
-                    .forEach { pair ->
-                        val req = SyncWorker.buildPeriodicRequest(
-                            pair.id,
-                            pair.scheduleIntervalMinutes.toLong().coerceAtLeast(15),
-                            pair.wifiOnly,
-                            pair.chargingOnly,
-                        )
-                        wm.enqueueUniquePeriodicWork("periodic_${pair.id}", androidx.work.ExistingPeriodicWorkPolicy.UPDATE, req)
+                val pairs = syncPairDao.getEnabled()
+                var hasOnChange = false
+                pairs.forEach { pair ->
+                    when (pair.scheduleType) {
+                        ScheduleType.ON_CHANGE -> hasOnChange = true
+                        ScheduleType.MANUAL -> { /* nothing */ }
+                        else -> {
+                            val req = SyncWorker.buildPeriodicRequest(
+                                pair.id,
+                                pair.scheduleIntervalMinutes.toLong().coerceAtLeast(15),
+                                pair.wifiOnly,
+                                pair.chargingOnly,
+                            )
+                            wm.enqueueUniquePeriodicWork("periodic_${pair.id}", ExistingPeriodicWorkPolicy.UPDATE, req)
+                        }
                     }
+                }
+                if (hasOnChange) FileWatchService.start(context)
             } finally {
                 pending.finish()
             }

app/src/main/kotlin/com/syncflow/worker/FileWatchService.kt

@@ -0,0 +1,182 @@
+package com.syncflow.worker
+
+import android.app.*
+import android.content.Context
+import android.content.Intent
+import android.database.ContentObserver
+import android.net.Uri
+import android.os.Build
+import android.os.FileObserver
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import androidx.core.app.NotificationCompat
+import androidx.work.ExistingWorkPolicy
+import androidx.work.WorkManager
+import com.syncflow.MainActivity
+import com.syncflow.R
+import com.syncflow.data.db.SyncPairDao
+import com.syncflow.domain.model.ScheduleType
+import dagger.hilt.android.AndroidEntryPoint
+import kotlinx.coroutines.*
+import timber.log.Timber
+import java.io.File
+import javax.inject.Inject
+
+@AndroidEntryPoint
+class FileWatchService : Service() {
+
+    @Inject lateinit var syncPairDao: SyncPairDao
+
+    private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    private val fileObservers = mutableMapOf<Long, FileObserver>()
+    private val contentObservers = mutableMapOf<Long, ContentObserver>()
+    private val debounceJobs = mutableMapOf<Long, Job>()
+
+    companion object {
+        const val CHANNEL_WATCH = "sync_watching"
+        private const val NOTIFICATION_ID = 1002
+
+        fun start(context: Context) {
+            val intent = Intent(context, FileWatchService::class.java)
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                context.startForegroundService(intent)
+            } else {
+                context.startService(intent)
+            }
+        }
+
+        fun stop(context: Context) {
+            context.stopService(Intent(context, FileWatchService::class.java))
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        ensureChannel()
+        startForeground(NOTIFICATION_ID, buildNotification(0))
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        scope.launch { refresh() }
+        return START_STICKY
+    }
+
+    override fun onDestroy() {
+        clearWatchers()
+        scope.cancel()
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    private suspend fun refresh() {
+        clearWatchers()
+        val pairs = syncPairDao.getEnabled().filter { it.scheduleType == ScheduleType.ON_CHANGE }
+
+        pairs.forEach { pair ->
+            val pairId = pair.id
+            val localPath = pair.localPath
+
+            if (localPath.startsWith("content://")) {
+                val treeUri = Uri.parse(localPath)
+                val observer = object : ContentObserver(mainHandler) {
+                    override fun onChange(selfChange: Boolean) = onChangeDetected(pairId, pair.wifiOnly, pair.chargingOnly)
+                    override fun onChange(selfChange: Boolean, uri: Uri?) = onChangeDetected(pairId, pair.wifiOnly, pair.chargingOnly)
+                }
+                contentResolver.registerContentObserver(treeUri, true, observer)
+                contentObservers[pairId] = observer
+                Timber.d("FileWatchService: watching SAF URI for pair $pairId")
+            } else {
+                val dir = File(localPath)
+                if (!dir.exists()) {
+                    Timber.w("FileWatchService: path does not exist for pair $pairId: $localPath")
+                    return@forEach
+                }
+                val mask = FileObserver.CREATE or FileObserver.DELETE or FileObserver.MODIFY or
+                           FileObserver.MOVED_FROM or FileObserver.MOVED_TO
+                val observer = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                    object : FileObserver(dir, mask) {
+                        override fun onEvent(event: Int, path: String?) = onChangeDetected(pairId, pair.wifiOnly, pair.chargingOnly)
+                    }
+                } else {
+                    @Suppress("DEPRECATION")
+                    object : FileObserver(localPath, mask) {
+                        override fun onEvent(event: Int, path: String?) = onChangeDetected(pairId, pair.wifiOnly, pair.chargingOnly)
+                    }
+                }
+                observer.startWatching()
+                fileObservers[pairId] = observer
+                Timber.d("FileWatchService: watching filesystem path for pair $pairId: $localPath")
+            }
+        }
+
+        val count = fileObservers.size + contentObservers.size
+        updateNotification(count)
+
+        if (count == 0) {
+            Timber.d("FileWatchService: no ON_CHANGE pairs, stopping")
+            stopSelf()
+        }
+    }
+
+    private fun onChangeDetected(pairId: Long, wifiOnly: Boolean, chargingOnly: Boolean) {
+        debounceJobs[pairId]?.cancel()
+        debounceJobs[pairId] = scope.launch {
+            delay(5_000)
+            val pair = syncPairDao.getById(pairId)
+            if (pair == null || !pair.isEnabled) return@launch
+            Timber.d("FileWatchService: triggering sync for pair $pairId after debounce")
+            val req = SyncWorker.buildOneTimeRequest(pairId, wifiOnly, chargingOnly)
+            WorkManager.getInstance(applicationContext)
+                .enqueueUniqueWork("onchange_$pairId", ExistingWorkPolicy.KEEP, req)
+        }
+    }
+
+    private fun clearWatchers() {
+        fileObservers.values.forEach { it.stopWatching() }
+        fileObservers.clear()
+        contentObservers.values.forEach { contentResolver.unregisterContentObserver(it) }
+        contentObservers.clear()
+        debounceJobs.values.forEach { it.cancel() }
+        debounceJobs.clear()
+    }
+
+    private fun ensureChannel() {
+        val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        if (nm.getNotificationChannel(CHANNEL_WATCH) == null) {
+            nm.createNotificationChannel(
+                NotificationChannel(CHANNEL_WATCH, "File watching", NotificationManager.IMPORTANCE_LOW).apply {
+                    description = "Background service watching folders for changes"
+                    setShowBadge(false)
+                }
+            )
+        }
+    }
+
+    private fun buildNotification(count: Int): Notification {
+        val tapIntent = PendingIntent.getActivity(
+            this, 0,
+            Intent(this, MainActivity::class.java).apply { flags = Intent.FLAG_ACTIVITY_SINGLE_TOP },
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+        return NotificationCompat.Builder(this, CHANNEL_WATCH)
+            .setContentTitle("SyncFlow")
+            .setContentText(
+                if (count > 0) "Watching $count folder${if (count != 1) "s" else ""} for changes"
+                else "Starting file watcher…"
+            )
+            .setSmallIcon(R.drawable.ic_sync)
+            .setContentIntent(tapIntent)
+            .setOngoing(true)
+            .setPriority(NotificationCompat.PRIORITY_MIN)
+            .build()
+    }
+
+    private fun updateNotification(count: Int) {
+        val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        nm.notify(NOTIFICATION_ID, buildNotification(count))
+    }
+}

app/src/main/kotlin/com/syncflow/worker/SyncWorker.kt

@@ -2,12 +2,15 @@ package com.syncflow.worker
 
 import android.app.NotificationChannel
 import android.app.NotificationManager
+import android.app.PendingIntent
 import android.content.Context
+import android.content.Intent
 import android.content.pm.ServiceInfo
 import android.os.Build
 import androidx.core.app.NotificationCompat
 import androidx.hilt.work.HiltWorker
 import androidx.work.*
+import com.syncflow.MainActivity
 import com.syncflow.R
 import com.syncflow.data.db.SyncPairDao
 import com.syncflow.data.db.entities.toDomain
@@ -33,44 +36,121 @@ class SyncWorker @AssistedInject constructor(
         val pairId = inputData.getLong(KEY_PAIR_ID, -1L)
         if (pairId == -1L) return Result.failure()
 
-        setForeground(buildForegroundInfo("Syncing…"))
-
         val pair = syncPairDao.getById(pairId) ?: return Result.failure()
         val account = accountRepository.getAccount(pair.accountId) ?: return Result.failure()
 
+        ensureChannels()
+        setForeground(buildForegroundInfo(pair.name, "Syncing…"))
+
         return try {
             val domainPair = pair.toDomain()
             val provider = providerFactory.create(account)
-            syncEngine.sync(domainPair, provider)
+            val result = syncEngine.sync(domainPair, provider)
+
+            if (result.error != null && pair.notifyOnError) {
+                notify(
+                    id = pairId.toInt() + RESULT_ID_OFFSET,
+                    channelId = CHANNEL_ALERTS,
+                    title = "${pair.name} — Sync failed",
+                    text = result.error.message ?: "Unknown error",
+                    priority = NotificationCompat.PRIORITY_DEFAULT,
+                )
+            } else if (pair.notifyOnComplete && result.error == null) {
+                val lines = buildList {
+                    if (result.uploaded > 0)   add("↑ Uploaded: ${result.uploaded} file${if (result.uploaded != 1) "s" else ""}")
+                    if (result.downloaded > 0) add("↓ Downloaded: ${result.downloaded} file${if (result.downloaded != 1) "s" else ""}")
+                    if (result.deleted > 0)    add("🗑 Deleted: ${result.deleted} file${if (result.deleted != 1) "s" else ""}")
+                    if (result.conflicts > 0)  add("⚠ ${result.conflicts} conflict${if (result.conflicts != 1) "s" else ""}")
+                }
+                val summary = if (lines.isEmpty()) "Up to date — nothing to sync" else lines.joinToString("\n")
+                notify(
+                    id = pairId.toInt() + RESULT_ID_OFFSET,
+                    channelId = CHANNEL_COMPLETE,
+                    title = "${pair.name} — Changes synced",
+                    text = if (lines.isEmpty()) summary else lines.first(),
+                    bigText = summary,
+                    priority = NotificationCompat.PRIORITY_LOW,
+                )
+            }
+
             Result.success()
         } catch (e: Exception) {
             Timber.e(e, "SyncWorker failed for pair $pairId")
+            if (pair.notifyOnError) {
+                notify(
+                    id = pairId.toInt() + RESULT_ID_OFFSET,
+                    channelId = CHANNEL_ALERTS,
+                    title = "${pair.name} — Sync failed",
+                    text = e.message ?: "Unknown error",
+                    priority = NotificationCompat.PRIORITY_DEFAULT,
+                )
+            }
             if (runAttemptCount < 3) Result.retry() else Result.failure()
         }
     }
 
-    private fun buildForegroundInfo(progress: String): ForegroundInfo {
-        val channelId = "sync_channel"
+    private fun ensureChannels() {
         val nm = applicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-        if (nm.getNotificationChannel(channelId) == null) {
-            nm.createNotificationChannel(NotificationChannel(channelId, "Sync", NotificationManager.IMPORTANCE_LOW))
-        }
-        val notification = NotificationCompat.Builder(applicationContext, channelId)
-            .setContentTitle("SyncFlow")
-            .setContentText(progress)
+        if (nm.getNotificationChannel(CHANNEL_PROGRESS) == null)
+            nm.createNotificationChannel(NotificationChannel(CHANNEL_PROGRESS, "Sync progress", NotificationManager.IMPORTANCE_LOW).apply {
+                description = "Shown while a sync is running"
+            })
+        if (nm.getNotificationChannel(CHANNEL_COMPLETE) == null)
+            nm.createNotificationChannel(NotificationChannel(CHANNEL_COMPLETE, "Sync complete", NotificationManager.IMPORTANCE_LOW).apply {
+                description = "Summary after each successful sync"
+            })
+        if (nm.getNotificationChannel(CHANNEL_ALERTS) == null)
+            nm.createNotificationChannel(NotificationChannel(CHANNEL_ALERTS, "Sync errors", NotificationManager.IMPORTANCE_DEFAULT).apply {
+                description = "Alerts for sync failures and conflicts"
+            })
+    }
+
+    private fun buildForegroundInfo(pairName: String, status: String): ForegroundInfo {
+        val tapIntent = PendingIntent.getActivity(
+            applicationContext, 0,
+            Intent(applicationContext, MainActivity::class.java).apply { flags = Intent.FLAG_ACTIVITY_SINGLE_TOP },
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+        val notification = NotificationCompat.Builder(applicationContext, CHANNEL_PROGRESS)
+            .setContentTitle(pairName)
+            .setContentText(status)
             .setSmallIcon(R.drawable.ic_sync)
+            .setContentIntent(tapIntent)
             .setOngoing(true)
             .build()
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
             ForegroundInfo(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC)
-        } else {
+        else
             ForegroundInfo(NOTIFICATION_ID, notification)
+    }
+
+    private fun notify(id: Int, channelId: String, title: String, text: String, priority: Int, bigText: String? = null) {
+        val tapIntent = PendingIntent.getActivity(
+            applicationContext, id,
+            Intent(applicationContext, MainActivity::class.java).apply { flags = Intent.FLAG_ACTIVITY_SINGLE_TOP },
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+        val nm = applicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val builder = NotificationCompat.Builder(applicationContext, channelId)
+            .setContentTitle(title)
+            .setContentText(text)
+            .setSmallIcon(R.drawable.ic_sync)
+            .setPriority(priority)
+            .setContentIntent(tapIntent)
+            .setAutoCancel(true)
+        if (bigText != null) {
+            builder.setStyle(NotificationCompat.BigTextStyle().bigText(bigText))
         }
+        nm.notify(id, builder.build())
     }
 
     companion object {
         const val KEY_PAIR_ID = "pair_id"
         private const val NOTIFICATION_ID = 1001
+        private const val RESULT_ID_OFFSET = 2000
+        private const val CHANNEL_PROGRESS = "sync_progress"
+        private const val CHANNEL_COMPLETE = "sync_complete"
+        private const val CHANNEL_ALERTS   = "sync_alerts"
 
         fun buildOneTimeRequest(pairId: Long, wifiOnly: Boolean, chargingOnly: Boolean): OneTimeWorkRequest {
             val constraints = Constraints.Builder()

app/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<shape xmlns:android="http://schemas.android.com/apk/res/android">
+    <gradient
+        android:type="linear"
+        android:angle="135"
+        android:startColor="#2E1065"
+        android:centerColor="#6D28D9"
+        android:endColor="#1E40AF"/>
+</shape>

app/src/main/res/drawable/ic_launcher_foreground.xml

@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+
+    <!-- Outer soft glow ring -->
+    <path
+        android:pathData="M54,54m-44,0a44,44 0 1,0 88,0a44,44 0 1,0 -88,0"
+        android:fillColor="#12FFFFFF"/>
+
+    <!-- Mid glow ring -->
+    <path
+        android:pathData="M54,54m-33,0a33,33 0 1,0 66,0a33,33 0 1,0 -66,0"
+        android:fillColor="#18FFFFFF"/>
+
+    <!-- Inner glow ring -->
+    <path
+        android:pathData="M54,54m-21,0a21,21 0 1,0 42,0a21,21 0 1,0 -42,0"
+        android:fillColor="#10FFFFFF"/>
+
+    <!-- Upload arrow (top-right) — neon cyan → sky blue -->
+    <path android:pathData="M54,18V4.5L36,22.5l18,18V27c14.895,0 27,12.105 27,27 0,4.545-1.125,8.865-3.15,12.6l6.57,6.57C87.93,67.635 90,61.065 90,54c0-19.89-16.11-36-36-36z">
+        <aapt:attr name="android:fillColor">
+            <gradient android:type="linear"
+                android:startX="36" android:startY="4"
+                android:endX="90" android:endY="70"
+                android:startColor="#67E8F9"
+                android:endColor="#38BDF8"/>
+        </aapt:attr>
+    </path>
+
+    <!-- Download arrow (bottom-left) — hot pink → coral -->
+    <path android:pathData="M54,81c-14.895,0-27,-12.105-27,-27 0,-4.545 1.125,-8.865 3.15,-12.6L23.58,34.83C20.07,40.365 18,46.935 18,54c0,19.89 16.11,36 36,36v13.5l18,-18-18,-18v13.5z">
+        <aapt:attr name="android:fillColor">
+            <gradient android:type="linear"
+                android:startX="18" android:startY="35"
+                android:endX="72" android:endY="103"
+                android:startColor="#F472B6"
+                android:endColor="#FB923C"/>
+        </aapt:attr>
+    </path>
+
+    <!-- Center glowing orb -->
+    <path
+        android:pathData="M54,54m-7,0a7,7 0 1,0 14,0a7,7 0 1,0 -14,0"
+        android:fillColor="#60FFFFFF"/>
+    <path
+        android:pathData="M54,54m-4,0a4,4 0 1,0 8,0a4,4 0 1,0 -8,0"
+        android:fillColor="#FFFFFF"/>
+
+    <!-- Cardinal accent sparks -->
+    <!-- Top — cyan -->
+    <path android:pathData="M54,13m-3,0a3,3 0 1,0 6,0a3,3 0 1,0 -6,0" android:fillColor="#22D3EE"/>
+    <!-- Right — indigo -->
+    <path android:pathData="M95,54m-3,0a3,3 0 1,0 6,0a3,3 0 1,0 -6,0" android:fillColor="#818CF8"/>
+    <!-- Bottom — pink -->
+    <path android:pathData="M54,95m-3,0a3,3 0 1,0 6,0a3,3 0 1,0 -6,0" android:fillColor="#F9A8D4"/>
+    <!-- Left — emerald -->
+    <path android:pathData="M13,54m-3,0a3,3 0 1,0 6,0a3,3 0 1,0 -6,0" android:fillColor="#6EE7B7"/>
+
+    <!-- Diagonal mini sparks (45°) -->
+    <path android:pathData="M85,23m-2,0a2,2 0 1,0 4,0a2,2 0 1,0 -4,0" android:fillColor="#A5F3FC"/>
+    <path android:pathData="M85,85m-2,0a2,2 0 1,0 4,0a2,2 0 1,0 -4,0" android:fillColor="#FDBA74"/>
+    <path android:pathData="M23,85m-2,0a2,2 0 1,0 4,0a2,2 0 1,0 -4,0" android:fillColor="#C084FC"/>
+    <path android:pathData="M23,23m-2,0a2,2 0 1,0 4,0a2,2 0 1,0 -4,0" android:fillColor="#86EFAC"/>
+
+</vector>

app/src/main/res/mipmap-hdpi/ic_launcher.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-hdpi/ic_launcher_round.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-mdpi/ic_launcher.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-mdpi/ic_launcher_round.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-xhdpi/ic_launcher.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-xhdpi/ic_launcher_round.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-xxhdpi/ic_launcher.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-xxhdpi/ic_launcher_round.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-xxxhdpi/ic_launcher.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-    <background android:drawable="@color/ic_launcher_background"/>
-    <foreground android:drawable="@drawable/ic_sync"/>
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

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.17
+VERSION_CODE=18