v1.0.32: fix manual sync loop via WorkManager tag monitor

Root cause: manual sync triggered from the UI had no cooldown set in
FileWatchService, so file writes during any manual sync fired FileObserver
→ debounce → another sync → loop.

Fix: startSyncMonitor() subscribes to getWorkInfosByTagFlow("sync_$pairId")
and watches ALL sync work for each pair — manual, catchup, onchange — via
the tag that SyncWorker.buildOneTimeRequest() always adds.
  - When any sync is RUNNING or ENQUEUED: cooldown extended to now+120s
  - When sync transitions from running to finished: 60s settle cooldown
  - Monitor job stored in syncMonitorJobs map and cancelled in clearWatchers()

This means no matter what triggers a sync, FileObserver events from the
resulting file writes are always suppressed until the folder settles.

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

app/src/main/AndroidManifest.xml

@@ -66,13 +66,16 @@
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
             </intent-filter>
         </receiver>
 
         <!-- File watcher for ON_CHANGE sync pairs -->
+        <!-- stopWithTask=false keeps the service alive when the user swipes the app away -->
         <service
             android:name=".worker.FileWatchService"
             android:foregroundServiceType="dataSync|shortService"
+            android:stopWithTask="false"
             android:exported="false" />
 
         <!-- Required on API 29+ so WorkManager can start a typed foreground service -->

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

@@ -2,9 +2,13 @@ package com.syncflow.data.db
 
 import androidx.room.*
 import com.syncflow.data.db.entities.SyncFileStateEntity
+import kotlinx.coroutines.flow.Flow
 
 @Dao
 interface SyncFileStateDao {
+    @Query("SELECT * FROM sync_file_states WHERE syncPairId = :pairId ORDER BY relativePath ASC")
+    fun observeForPair(pairId: Long): Flow<List<SyncFileStateEntity>>
+
     @Query("SELECT * FROM sync_file_states WHERE syncPairId = :pairId")
     suspend fun getForPair(pairId: Long): List<SyncFileStateEntity>
 

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

@@ -1,7 +1,7 @@
 package com.syncflow.data.providers.webdav
 
-import android.util.Log
 import com.syncflow.data.providers.CloudProvider
+import timber.log.Timber
 import com.syncflow.domain.model.CloudAccount
 import com.syncflow.domain.model.RemoteFile
 import kotlinx.coroutines.Dispatchers
@@ -59,14 +59,13 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
         withContext(Dispatchers.IO) {
             val req = Request.Builder().url(baseUrl).method("PROPFIND", PROPFIND_BODY).header("Depth", "0").build()
             client.newCall(req).execute().use { resp ->
-                Log.d("SyncFlow/WebDAV", "testConnection ${resp.code} url=$baseUrl")
+                Timber.d("WebDAV testConnection %d url=%s", resp.code, baseUrl)
                 if (!resp.isSuccessful && resp.code != 207) {
-                    val body = resp.body?.string()?.take(300) ?: ""
-                    throw Exception("HTTP ${resp.code} ${resp.message} — $body")
+                    throw Exception("HTTP ${resp.code} ${resp.message}")
                 }
             }
         }
-    }.onFailure { e -> Log.e("SyncFlow/WebDAV", "testConnection failed: ${e::class.simpleName}: ${e.message}", e.cause) }
+    }.onFailure { e -> Timber.e(e, "WebDAV testConnection failed") }
 
     override suspend fun listFiles(remotePath: String): Result<List<RemoteFile>> = runCatching {
         withContext(Dispatchers.IO) {
@@ -192,9 +191,14 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
                     "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
+                        // Guard against path-traversal sequences delivered by a malicious server
+                        if (name.contains("..") || name.contains('/') || name.contains('\\')) {
+                            inResponse = false
+                        } else {
+                            val relPath = "$parentPath/$name".replace("//", "/")
+                            results.add(RemoteFile(relPath, name, isCollection, contentLength, lastModified, etag, contentType))
+                            inResponse = false
+                        }
                     }
                 }
             }

app/src/main/kotlin/com/syncflow/data/security/CredentialStore.kt

@@ -12,6 +12,7 @@ import javax.inject.Singleton
 class CredentialStore @Inject constructor(@ApplicationContext private val context: Context) {
 
     private val prefs: SharedPreferences by lazy {
+        @Suppress("DEPRECATION")
         val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
         EncryptedSharedPreferences.create(
             "syncflow_credentials",

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

@@ -46,7 +46,7 @@ class SyncEngine @Inject constructor(
                 else -> SyncStatus.SUCCESS
             }
             syncPairDao.updateSyncResult(pair.id, Instant.now(), finalStatus, result.conflicts)
-            logEvent(pair.id, SyncEventType.SYNC_COMPLETED, null, "↑${result.uploaded} ↓${result.downloaded} ✗${result.failedFiles}", result.bytesTransferred)
+            logEvent(pair.id, SyncEventType.SYNC_COMPLETED, null, "↑${result.uploaded} ↓${result.downloaded} ✕${result.deleted} ✗${result.failedFiles}", result.bytesTransferred)
             result
         } catch (e: Exception) {
             Timber.e(e, "Sync failed for pair ${pair.id}")
@@ -62,13 +62,28 @@ class SyncEngine @Inject constructor(
         else
             LocalAccessor.JavaFile(File(localPath))
 
-    private suspend fun performSync(pair: SyncPair, provider: CloudProvider): SyncResult {
+    private suspend fun performSync(
+        pair: SyncPair,
+        provider: CloudProvider,
+        isRetry: Boolean = false,
+    ): SyncResult {
         val accessor = makeAccessor(pair.localPath)
-        val knownStates = fileStateDao.getForPair(pair.id).associateBy { it.relativePath }
+        var knownStates = fileStateDao.getForPair(pair.id).associateBy { it.relativePath }
         val remoteFiles = provider.listFiles(pair.remotePath).getOrThrow()
             .associateBy { it.path.removePrefix(pair.remotePath).trimStart('/') }
         val localFiles = accessor.walkFiles(pair)
 
+        // Self-healing: if every known-state path is absent from the current local scan but
+        // the local folder does have files, the localPath was changed without clearing state.
+        // The stale records would cause every old file to look like "DELETE_REMOTE" and every
+        // new file to re-upload indefinitely. Wipe and retry once as a fresh initial sync.
+        if (!isRetry && knownStates.isNotEmpty() && localFiles.isNotEmpty() &&
+            knownStates.keys.none { it in localFiles }) {
+            Timber.w("SyncEngine: stale folder states detected for pair ${pair.id} — resetting")
+            fileStateDao.deleteForPair(pair.id)
+            return performSync(pair, provider, isRetry = true)
+        }
+
         val allPaths = (localFiles.keys + remoteFiles.keys + knownStates.keys).toSet()
         val hasPriorSyncState = knownStates.isNotEmpty()
         val semaphore = Semaphore(4)
@@ -126,7 +141,9 @@ class SyncEngine @Inject constructor(
                                 logEvent(pair.id, SyncEventType.FILE_DOWNLOADED, rel, null, bytes)
                                 FileOutcome(downloaded = 1, bytesTransferred = bytes,
                                     newState = buildState(pair.id, rel,
-                                        LocalFileInfo(rel, remote!!.sizeBytes, localMtime), remoteAfterTransfer = remote))
+                                        LocalFileInfo(rel, remote!!.sizeBytes, localMtime),
+                                        remoteAfterTransfer = remote,
+                                        storeLocalMtime = false))
                             }
                             SyncDecision.DELETE_LOCAL -> {
                                 accessor.delete(rel)
@@ -203,10 +220,13 @@ class SyncEngine @Inject constructor(
         rel: String,
         local: LocalFileInfo?,
         remoteAfterTransfer: RemoteFile?,
+        storeLocalMtime: Boolean = true,
     ) = SyncFileStateEntity(
         syncPairId = pairId,
         relativePath = rel,
-        localModifiedAt = local?.lastModifiedMs?.let { Instant.ofEpochMilli(it) },
+        // When storeLocalMtime=false, leave localModifiedAt null so the SKIP reconciliation
+        // pass on the next sync reads it from the walkFiles cursor (avoids SAF stale-mtime loops).
+        localModifiedAt = if (storeLocalMtime) local?.lastModifiedMs?.let { Instant.ofEpochMilli(it) } else null,
         localSizeBytes = local?.sizeBytes ?: 0L,
         localHash = null,
         remoteModifiedAt = remoteAfterTransfer?.modifiedAt,
@@ -236,12 +256,16 @@ internal fun syncDecide(
 
     // 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.
+    // Use second-precision for both sides: FAT32 has 2-second mtime resolution, WebDAV
+    // RFC-1123 has 1-second resolution, so millisecond comparison causes phantom "changed"
+    // detections and rewrite loops after a fresh download/upload.
     val localChanged = known == null ||
         (localExists && known.localModifiedAt != null &&
-            local!!.lastModifiedMs != known.localModifiedAt.toEpochMilli())
+            local!!.lastModifiedMs / 1000 != known.localModifiedAt.epochSecond)
     val remoteChanged = known == null ||
         (remoteExists && known.remoteModifiedAt != null &&
-            (remote!!.etag != known.remoteEtag || remote.modifiedAt != known.remoteModifiedAt))
+            (remote!!.etag != known.remoteEtag ||
+             remote.modifiedAt.epochSecond != known.remoteModifiedAt.epochSecond))
 
     return when {
         !localExists && !remoteExists -> SyncDecision.SKIP

app/src/main/kotlin/com/syncflow/ui/addpair/AddPairViewModel.kt

@@ -5,6 +5,7 @@ import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.syncflow.data.db.CloudAccountDao
+import com.syncflow.data.db.SyncFileStateDao
 import com.syncflow.data.db.SyncPairDao
 import com.syncflow.data.db.entities.CloudAccountEntity
 import com.syncflow.data.db.entities.SyncPairEntity
@@ -58,6 +59,7 @@ data class AddPairUiState(
 @HiltViewModel
 class AddPairViewModel @Inject constructor(
     private val syncPairDao: SyncPairDao,
+    private val fileStateDao: SyncFileStateDao,
     private val accountDao: CloudAccountDao,
     @ApplicationContext private val context: Context,
     savedState: SavedStateHandle,
@@ -148,7 +150,20 @@ class AddPairViewModel @Inject constructor(
                     notifyOnComplete = s.notifyOnComplete, notifyOnError = s.notifyOnError,
                     isEnabled = true, lastSyncAt = null, lastSyncResult = SyncStatus.IDLE, pendingConflicts = 0,
                 )
-                if (editPairId == null) syncPairDao.insert(entity) else syncPairDao.update(entity)
+                if (editPairId == null) {
+                    syncPairDao.insert(entity)
+                } else {
+                    val existing = syncPairDao.getById(editPairId)
+                    syncPairDao.update(entity)
+                    // If local or remote folder changed, old file-state records no longer
+                    // correspond to any real path — wipe them so the next sync starts fresh
+                    // instead of trying to delete/re-upload stale paths.
+                    if (existing != null &&
+                        (existing.localPath != entity.localPath || existing.remotePath != entity.remotePath)
+                    ) {
+                        fileStateDao.deleteForPair(editPairId)
+                    }
+                }
             }
                 .onSuccess {
                     if (s.scheduleType == ScheduleType.ON_CHANGE) FileWatchService.start(context)

app/src/main/kotlin/com/syncflow/ui/files/FilesScreen.kt

@@ -0,0 +1,527 @@
+package com.syncflow.ui.files
+
+import android.content.ClipData
+import android.content.Intent
+import android.net.Uri
+import android.webkit.MimeTypeMap
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.combinedClickable
+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.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.core.content.FileProvider
+import androidx.hilt.navigation.compose.hiltViewModel
+import com.syncflow.data.db.entities.SyncFileStateEntity
+import kotlinx.coroutines.launch
+import java.io.File
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class)
+@Composable
+fun FilesScreen(
+    modifier: Modifier = Modifier,
+    vm: FilesViewModel = hiltViewModel(),
+) {
+    val pairs by vm.pairs.collectAsState()
+    val selectedPair by vm.selectedPair.collectAsState()
+    val files by vm.files.collectAsState()
+    val isDownloading by vm.isDownloading.collectAsState()
+    val selectedKeys by vm.selectedKeys.collectAsState()
+    val isSelectionMode = selectedKeys.isNotEmpty()
+    val selectedCount = selectedKeys.size
+    val context = LocalContext.current
+    val snackbarHostState = remember { SnackbarHostState() }
+    val scope = rememberCoroutineScope()
+    var showDeleteSelectedDialog by remember { mutableStateOf(false) }
+
+    BackHandler(enabled = isSelectionMode) { vm.clearSelection() }
+
+    LaunchedEffect(Unit) {
+        vm.fileAction.collect { action ->
+            when (action) {
+                is FileAction.Open -> {
+                    try {
+                        val uri = FileProvider.getUriForFile(
+                            context, "${context.packageName}.fileprovider", action.file
+                        )
+                        val mimeType = action.file.name.mimeType()
+                        val intent = Intent(Intent.ACTION_VIEW).apply {
+                            setDataAndType(uri, mimeType)
+                            // ClipData is required so FLAG_GRANT_READ_URI_PERMISSION
+                            // propagates to whichever app the system chooser picks.
+                            clipData = ClipData.newRawUri("", uri)
+                            addFlags(
+                                Intent.FLAG_GRANT_READ_URI_PERMISSION or
+                                Intent.FLAG_ACTIVITY_NEW_TASK
+                            )
+                        }
+                        context.startActivity(intent)
+                    } catch (e: Exception) {
+                        snackbarHostState.showSnackbar("Cannot open file: ${e.message}")
+                    }
+                }
+                is FileAction.Share -> {
+                    try {
+                        val uri = FileProvider.getUriForFile(
+                            context, "${context.packageName}.fileprovider", action.file
+                        )
+                        val intent = Intent(Intent.ACTION_SEND).apply {
+                            type = action.file.name.mimeType()
+                            putExtra(Intent.EXTRA_STREAM, uri)
+                            clipData = ClipData.newRawUri("", uri)
+                            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+                        }
+                        context.startActivity(
+                            Intent.createChooser(intent, "Share via").apply {
+                                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            }
+                        )
+                    } catch (e: Exception) {
+                        snackbarHostState.showSnackbar("Cannot share file: ${e.message}")
+                    }
+                }
+                is FileAction.ShareMultiple -> {
+                    try {
+                        val uris = action.files.map { file ->
+                            FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", file)
+                        }
+                        val intent = Intent(Intent.ACTION_SEND_MULTIPLE).apply {
+                            type = "*/*"
+                            putParcelableArrayListExtra(Intent.EXTRA_STREAM, ArrayList(uris))
+                            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+                        }
+                        context.startActivity(
+                            Intent.createChooser(intent, "Share files").apply {
+                                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                            }
+                        )
+                    } catch (e: Exception) {
+                        snackbarHostState.showSnackbar("Cannot share: ${e.message}")
+                    }
+                }
+                is FileAction.Error -> scope.launch {
+                    snackbarHostState.showSnackbar(action.message)
+                }
+            }
+        }
+    }
+
+    if (showDeleteSelectedDialog) {
+        AlertDialog(
+            onDismissRequest = { showDeleteSelectedDialog = false },
+            icon = { Icon(Icons.Default.Delete, contentDescription = null) },
+            title = { Text("Delete $selectedCount file${if (selectedCount != 1) "s" else ""}?") },
+            text = { Text("Selected files will be removed from this device.") },
+            confirmButton = {
+                TextButton(onClick = {
+                    vm.deleteSelected()
+                    showDeleteSelectedDialog = false
+                }) { Text("Delete", color = MaterialTheme.colorScheme.error) }
+            },
+            dismissButton = {
+                TextButton(onClick = { showDeleteSelectedDialog = false }) { Text("Cancel") }
+            },
+        )
+    }
+
+    Box(modifier = modifier.fillMaxSize()) {
+        Column(modifier = Modifier.fillMaxSize()) {
+            // Selection toolbar
+            if (isSelectionMode) {
+                Surface(
+                    color = MaterialTheme.colorScheme.primaryContainer,
+                    tonalElevation = 3.dp,
+                ) {
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(horizontal = 4.dp, vertical = 4.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        IconButton(onClick = { vm.clearSelection() }) {
+                            Icon(Icons.Default.Close, contentDescription = "Clear selection")
+                        }
+                        Text(
+                            "$selectedCount selected",
+                            style = MaterialTheme.typography.titleSmall,
+                            modifier = Modifier.weight(1f),
+                        )
+                        IconButton(onClick = { vm.shareSelected() }) {
+                            Icon(Icons.Default.Share, contentDescription = "Share selected")
+                        }
+                        IconButton(onClick = { showDeleteSelectedDialog = true }) {
+                            Icon(
+                                Icons.Default.Delete, contentDescription = "Delete selected",
+                                tint = MaterialTheme.colorScheme.error,
+                            )
+                        }
+                    }
+                }
+                HorizontalDivider()
+            }
+
+            // Pair tabs
+            if (pairs.size > 1 && !isSelectionMode) {
+                ScrollableTabRow(
+                    selectedTabIndex = pairs.indexOfFirst { it.id == selectedPair?.id }.coerceAtLeast(0),
+                    edgePadding = 16.dp,
+                    containerColor = MaterialTheme.colorScheme.surface,
+                    divider = {},
+                ) {
+                    pairs.forEach { pair ->
+                        Tab(
+                            selected = pair.id == selectedPair?.id,
+                            onClick = { vm.selectPair(pair.id) },
+                            text = { Text(pair.name, maxLines = 1, overflow = TextOverflow.Ellipsis) },
+                        )
+                    }
+                }
+                HorizontalDivider()
+            }
+
+            when {
+                pairs.isEmpty() -> FilesEmptyState(
+                    icon = Icons.Default.FolderOpen,
+                    title = "No sync pairs yet",
+                    subtitle = "Create a sync pair to browse its files",
+                )
+                files.isEmpty() -> FilesEmptyState(
+                    icon = Icons.Default.FolderOpen,
+                    title = "No synced files yet",
+                    subtitle = "Run a sync to populate this view",
+                )
+                else -> {
+                    if (!isSelectionMode) {
+                        Surface(color = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.5f)) {
+                            Row(
+                                modifier = Modifier
+                                    .fillMaxWidth()
+                                    .padding(horizontal = 16.dp, vertical = 8.dp),
+                                horizontalArrangement = Arrangement.SpaceBetween,
+                                verticalAlignment = Alignment.CenterVertically,
+                            ) {
+                                Text(
+                                    "${files.size} file${if (files.size != 1) "s" else ""}",
+                                    style = MaterialTheme.typography.labelMedium,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                )
+                                Text(
+                                    files.sumOf { it.localSizeBytes }.toDisplaySize(),
+                                    style = MaterialTheme.typography.labelMedium,
+                                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                )
+                            }
+                        }
+                    }
+
+                    LazyColumn(
+                        contentPadding = PaddingValues(horizontal = 16.dp, vertical = 8.dp),
+                        verticalArrangement = Arrangement.spacedBy(0.dp),
+                    ) {
+                        val grouped = files.groupBy { f ->
+                            val idx = f.relativePath.indexOf('/')
+                            if (idx < 0) "" else f.relativePath.substring(0, idx)
+                        }
+                        grouped.forEach { (dir, dirFiles) ->
+                            if (dir.isNotEmpty() && !isSelectionMode) {
+                                item(key = "dir_$dir") {
+                                    Row(
+                                        modifier = Modifier.padding(top = 12.dp, bottom = 4.dp),
+                                        verticalAlignment = Alignment.CenterVertically,
+                                    ) {
+                                        Icon(
+                                            Icons.Default.Folder, contentDescription = null,
+                                            modifier = Modifier.size(16.dp),
+                                            tint = MaterialTheme.colorScheme.primary,
+                                        )
+                                        Spacer(Modifier.width(6.dp))
+                                        Text(
+                                            dir,
+                                            style = MaterialTheme.typography.labelMedium,
+                                            color = MaterialTheme.colorScheme.primary,
+                                        )
+                                    }
+                                }
+                            }
+                            items(dirFiles, key = { "${it.syncPairId}_${it.relativePath}" }) { file ->
+                                FileRow(
+                                    file = file,
+                                    isInSubDir = dir.isNotEmpty() && !isSelectionMode,
+                                    isSelectionMode = isSelectionMode,
+                                    isSelected = vm.fileKey(file) in selectedKeys,
+                                    vm = vm,
+                                )
+                                HorizontalDivider(
+                                    color = MaterialTheme.colorScheme.outline.copy(alpha = 0.25f),
+                                    modifier = Modifier.padding(start = if (dir.isNotEmpty() && !isSelectionMode) 38.dp else 16.dp),
+                                )
+                            }
+                        }
+                        item { Spacer(Modifier.height(80.dp)) }
+                    }
+                }
+            }
+        }
+
+        // Download progress
+        if (isDownloading) {
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .align(Alignment.BottomCenter),
+            ) {
+                Surface(
+                    color = MaterialTheme.colorScheme.surfaceVariant,
+                    tonalElevation = 4.dp,
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .padding(horizontal = 16.dp, vertical = 10.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(12.dp),
+                    ) {
+                        CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp)
+                        Text("Downloading for preview…", style = MaterialTheme.typography.bodySmall)
+                    }
+                }
+            }
+        }
+
+        SnackbarHost(
+            hostState = snackbarHostState,
+            modifier = Modifier.align(Alignment.BottomCenter),
+        )
+    }
+}
+
+@Composable
+private fun FilesEmptyState(icon: ImageVector, title: String, subtitle: String) {
+    Box(modifier = Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            Icon(
+                icon, contentDescription = null,
+                modifier = Modifier.size(72.dp),
+                tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.35f),
+            )
+            Text(title, style = MaterialTheme.typography.titleMedium)
+            Text(
+                subtitle,
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}
+
+@OptIn(ExperimentalFoundationApi::class)
+@Composable
+private fun FileRow(
+    file: SyncFileStateEntity,
+    isInSubDir: Boolean,
+    isSelectionMode: Boolean,
+    isSelected: Boolean,
+    vm: FilesViewModel,
+) {
+    val name = file.relativePath.substringAfterLast('/')
+    val timeFmt = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT)
+    val syncedAt = file.lastSyncedAt.atZone(ZoneId.systemDefault()).let { timeFmt.format(it) }
+
+    var menuExpanded by remember { mutableStateOf(false) }
+    var showRenameDialog by remember { mutableStateOf(false) }
+    var showDeleteDialog by remember { mutableStateOf(false) }
+
+    if (showRenameDialog) {
+        RenameDialog(
+            currentName = name,
+            onConfirm = { newName -> vm.renameFile(file, newName); showRenameDialog = false },
+            onDismiss = { showRenameDialog = false },
+        )
+    }
+
+    if (showDeleteDialog) {
+        AlertDialog(
+            onDismissRequest = { showDeleteDialog = false },
+            icon = { Icon(Icons.Default.Delete, contentDescription = null) },
+            title = { Text("Delete file?") },
+            text = { Text("\"$name\" will be removed from this device.") },
+            confirmButton = {
+                TextButton(onClick = { vm.deleteFile(file); showDeleteDialog = false }) {
+                    Text("Delete", color = MaterialTheme.colorScheme.error)
+                }
+            },
+            dismissButton = {
+                TextButton(onClick = { showDeleteDialog = false }) { Text("Cancel") }
+            },
+        )
+    }
+
+    Surface(
+        color = if (isSelected) MaterialTheme.colorScheme.primaryContainer.copy(alpha = 0.4f)
+                else MaterialTheme.colorScheme.surface,
+        modifier = Modifier
+            .fillMaxWidth()
+            .combinedClickable(
+                onClick = {
+                    if (isSelectionMode) vm.toggleSelection(file) else menuExpanded = true
+                },
+                onLongClick = { vm.toggleSelection(file) },
+            ),
+    ) {
+        Row(
+            modifier = Modifier.padding(
+                start = if (isInSubDir) 22.dp else 0.dp,
+                top = 10.dp,
+                bottom = 10.dp,
+                end = 0.dp,
+            ),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            if (isSelectionMode) {
+                Checkbox(
+                    checked = isSelected,
+                    onCheckedChange = { vm.toggleSelection(file) },
+                    modifier = Modifier.padding(horizontal = 4.dp),
+                )
+            } else {
+                Surface(
+                    shape = RoundedCornerShape(8.dp),
+                    color = MaterialTheme.colorScheme.secondaryContainer,
+                    modifier = Modifier.size(32.dp),
+                ) {
+                    Box(contentAlignment = Alignment.Center) {
+                        Icon(
+                            fileIcon(name), contentDescription = null,
+                            modifier = Modifier.size(16.dp),
+                            tint = MaterialTheme.colorScheme.onSecondaryContainer,
+                        )
+                    }
+                }
+                Spacer(Modifier.width(12.dp))
+            }
+            Column(modifier = Modifier.weight(1f)) {
+                Text(
+                    name,
+                    style = MaterialTheme.typography.bodySmall,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                )
+                Text(
+                    "Synced $syncedAt · ${file.localSizeBytes.toDisplaySize()}",
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            if (!isSelectionMode) {
+                Box {
+                    IconButton(onClick = { menuExpanded = true }, modifier = Modifier.size(36.dp)) {
+                        Icon(
+                            Icons.Default.MoreVert, contentDescription = "File options",
+                            modifier = Modifier.size(18.dp),
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+                    DropdownMenu(expanded = menuExpanded, onDismissRequest = { menuExpanded = false }) {
+                        DropdownMenuItem(
+                            text = { Text("Open") },
+                            leadingIcon = { Icon(Icons.Default.OpenInNew, null) },
+                            onClick = { menuExpanded = false; vm.openFile(file) },
+                        )
+                        DropdownMenuItem(
+                            text = { Text("Share") },
+                            leadingIcon = { Icon(Icons.Default.Share, null) },
+                            onClick = { menuExpanded = false; vm.shareFile(file) },
+                        )
+                        HorizontalDivider()
+                        DropdownMenuItem(
+                            text = { Text("Rename") },
+                            leadingIcon = { Icon(Icons.Default.Edit, null) },
+                            onClick = { menuExpanded = false; showRenameDialog = true },
+                        )
+                        DropdownMenuItem(
+                            text = { Text("Delete", color = MaterialTheme.colorScheme.error) },
+                            leadingIcon = {
+                                Icon(Icons.Default.Delete, null, tint = MaterialTheme.colorScheme.error)
+                            },
+                            onClick = { menuExpanded = false; showDeleteDialog = true },
+                        )
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun RenameDialog(currentName: String, onConfirm: (String) -> Unit, onDismiss: () -> Unit) {
+    var newName by remember { mutableStateOf(currentName) }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        icon = { Icon(Icons.Default.Edit, contentDescription = null) },
+        title = { Text("Rename file") },
+        text = {
+            OutlinedTextField(
+                value = newName,
+                onValueChange = { newName = it },
+                label = { Text("New name") },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth(),
+            )
+        },
+        confirmButton = {
+            TextButton(
+                onClick = {
+                    val trimmed = newName.trim()
+                    if (trimmed.isNotBlank() && trimmed != currentName) onConfirm(trimmed) else onDismiss()
+                },
+                enabled = newName.isNotBlank(),
+            ) { Text("Rename") }
+        },
+        dismissButton = { TextButton(onClick = onDismiss) { Text("Cancel") } },
+    )
+}
+
+private fun String.mimeType(): String {
+    val ext = substringAfterLast('.', "").lowercase()
+    return MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext) ?: "*/*"
+}
+
+private fun fileIcon(name: String) = when {
+    name.endsWith(".pdf", ignoreCase = true) -> Icons.Default.PictureAsPdf
+    name.endsWith(".jpg", ignoreCase = true) || name.endsWith(".jpeg", ignoreCase = true) ||
+    name.endsWith(".png", ignoreCase = true) || name.endsWith(".gif", ignoreCase = true) ||
+    name.endsWith(".webp", ignoreCase = true) -> Icons.Default.Image
+    name.endsWith(".mp4", ignoreCase = true) || name.endsWith(".mkv", ignoreCase = true) ||
+    name.endsWith(".mov", ignoreCase = true) -> Icons.Default.VideoFile
+    name.endsWith(".mp3", ignoreCase = true) || name.endsWith(".m4a", ignoreCase = true) ||
+    name.endsWith(".ogg", ignoreCase = true) -> Icons.Default.AudioFile
+    name.endsWith(".zip", ignoreCase = true) || name.endsWith(".tar", ignoreCase = true) ||
+    name.endsWith(".gz", ignoreCase = true) -> Icons.Default.FolderZip
+    name.endsWith(".txt", ignoreCase = true) || name.endsWith(".md", ignoreCase = true) -> Icons.Default.TextSnippet
+    else -> Icons.Default.InsertDriveFile
+}
+
+private fun Long.toDisplaySize(): String = when {
+    this < 1_024 -> "$this B"
+    this < 1_048_576 -> "${"%.1f".format(this / 1_024.0)} KB"
+    this < 1_073_741_824 -> "${"%.1f".format(this / 1_048_576.0)} MB"
+    else -> "${"%.1f".format(this / 1_073_741_824.0)} GB"
+}

app/src/main/kotlin/com/syncflow/ui/files/FilesViewModel.kt

@@ -0,0 +1,241 @@
+package com.syncflow.ui.files
+
+import android.content.Context
+import android.media.MediaScannerConnection
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.syncflow.data.db.SyncFileStateDao
+import com.syncflow.data.db.SyncPairDao
+import com.syncflow.data.db.entities.SyncFileStateEntity
+import com.syncflow.data.db.entities.SyncPairEntity
+import com.syncflow.data.providers.ProviderFactory
+import com.syncflow.data.repository.AccountRepository
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.flow.update
+import timber.log.Timber
+import java.io.File
+import javax.inject.Inject
+
+sealed class FileAction {
+    data class Open(val file: File) : FileAction()
+    data class Share(val file: File) : FileAction()
+    data class ShareMultiple(val files: List<File>) : FileAction()
+    data class Error(val message: String) : FileAction()
+}
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltViewModel
+class FilesViewModel @Inject constructor(
+    private val syncPairDao: SyncPairDao,
+    private val fileStateDao: SyncFileStateDao,
+    private val accountRepository: AccountRepository,
+    private val providerFactory: ProviderFactory,
+    @ApplicationContext private val context: Context,
+) : ViewModel() {
+
+    val pairs: StateFlow<List<SyncPairEntity>> = syncPairDao.observeAll()
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
+    private val _selectedPairId = MutableStateFlow<Long?>(null)
+
+    val selectedPair: StateFlow<SyncPairEntity?> = combine(_selectedPairId, pairs) { id, list ->
+        list.firstOrNull { it.id == id } ?: list.firstOrNull()
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), null)
+
+    val files: StateFlow<List<SyncFileStateEntity>> = _selectedPairId
+        .flatMapLatest { id ->
+            if (id == null) pairs.map { it.firstOrNull()?.id }.filterNotNull()
+                .flatMapLatest { fileStateDao.observeForPair(it) }
+            else fileStateDao.observeForPair(id)
+        }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+
+    private val _fileAction = MutableSharedFlow<FileAction>()
+    val fileAction: SharedFlow<FileAction> = _fileAction
+
+    private val _isDownloading = MutableStateFlow(false)
+    val isDownloading: StateFlow<Boolean> = _isDownloading
+
+    private val _selectedKeys = MutableStateFlow<Set<String>>(emptySet())
+    val selectedKeys: StateFlow<Set<String>> = _selectedKeys
+    val isSelectionMode: StateFlow<Boolean> = _selectedKeys.map { it.isNotEmpty() }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), false)
+    val selectedCount: StateFlow<Int> = _selectedKeys.map { it.size }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), 0)
+
+    fun selectPair(id: Long) { _selectedPairId.value = id }
+
+    fun openFile(file: SyncFileStateEntity) {
+        val resolved = resolveFile(file, emitErrorIfMissing = false)
+        if (resolved != null) {
+            // Ensure MediaStore knows about this file so gallery apps can open it
+            MediaScannerConnection.scanFile(context, arrayOf(resolved.absolutePath), null, null)
+            viewModelScope.launch { _fileAction.emit(FileAction.Open(resolved)) }
+        } else {
+            downloadAndOpen(file)
+        }
+    }
+
+    fun shareFile(file: SyncFileStateEntity) {
+        val resolved = resolveFile(file, emitErrorIfMissing = false)
+        if (resolved != null) {
+            viewModelScope.launch { _fileAction.emit(FileAction.Share(resolved)) }
+        } else {
+            downloadAndShare(file)
+        }
+    }
+
+    fun deleteFile(file: SyncFileStateEntity) {
+        viewModelScope.launch {
+            try {
+                val resolved = resolveFile(file, emitErrorIfMissing = false)
+                resolved?.delete()
+                fileStateDao.delete(file.syncPairId, file.relativePath)
+            } catch (e: Exception) {
+                Timber.e(e, "Delete failed: ${file.relativePath}")
+                _fileAction.emit(FileAction.Error("Delete failed: ${e.message}"))
+            }
+        }
+    }
+
+    fun renameFile(file: SyncFileStateEntity, newName: String) {
+        viewModelScope.launch {
+            try {
+                val resolved = resolveFile(file) ?: return@launch
+                val parent = resolved.parentFile ?: return@launch
+                val dest = File(parent, newName)
+                if (!resolved.renameTo(dest)) {
+                    _fileAction.emit(FileAction.Error("Rename failed"))
+                    return@launch
+                }
+                fileStateDao.delete(file.syncPairId, file.relativePath)
+            } catch (e: Exception) {
+                Timber.e(e, "Rename failed: ${file.relativePath}")
+                _fileAction.emit(FileAction.Error("Rename failed: ${e.message}"))
+            }
+        }
+    }
+
+    fun isSelected(file: SyncFileStateEntity): Boolean = fileKey(file) in _selectedKeys.value
+
+    fun toggleSelection(file: SyncFileStateEntity) {
+        val key = fileKey(file)
+        _selectedKeys.update { if (key in it) it - key else it + key }
+    }
+
+    fun clearSelection() { _selectedKeys.value = emptySet() }
+
+    fun deleteSelected() {
+        viewModelScope.launch {
+            val toDelete = files.value.filter { isSelected(it) }
+            toDelete.forEach { file ->
+                try {
+                    resolveFile(file, emitErrorIfMissing = false)?.delete()
+                    fileStateDao.delete(file.syncPairId, file.relativePath)
+                } catch (e: Exception) {
+                    Timber.e(e, "Bulk delete failed: ${file.relativePath}")
+                }
+            }
+            clearSelection()
+        }
+    }
+
+    fun shareSelected() {
+        viewModelScope.launch {
+            val toShare = files.value.filter { isSelected(it) }
+            val resolved = toShare.mapNotNull { resolveFile(it, emitErrorIfMissing = false) }
+            if (resolved.isEmpty()) {
+                _fileAction.emit(FileAction.Error("No local files available to share"))
+                return@launch
+            }
+            _fileAction.emit(FileAction.ShareMultiple(resolved))
+        }
+    }
+
+    fun fileKey(file: SyncFileStateEntity) = "${file.syncPairId}:${file.relativePath}"
+
+    // ── Download-then-open/share ──────────────────────────────────────────────
+
+    private fun downloadAndOpen(file: SyncFileStateEntity) {
+        viewModelScope.launch {
+            downloadToCache(file)?.let { cached ->
+                _fileAction.emit(FileAction.Open(cached))
+            }
+        }
+    }
+
+    private fun downloadAndShare(file: SyncFileStateEntity) {
+        viewModelScope.launch {
+            downloadToCache(file)?.let { cached ->
+                _fileAction.emit(FileAction.Share(cached))
+            }
+        }
+    }
+
+    private suspend fun downloadToCache(file: SyncFileStateEntity): File? {
+        val pair = selectedPair.value ?: run {
+            _fileAction.emit(FileAction.Error("No sync pair selected"))
+            return null
+        }
+        val account = accountRepository.getAccount(pair.accountId) ?: run {
+            _fileAction.emit(FileAction.Error("Cloud account not found"))
+            return null
+        }
+        val provider = providerFactory.create(account)
+        val fileName = file.relativePath.substringAfterLast('/')
+        val cacheFile = File(context.cacheDir, "syncflow_open/$fileName")
+        cacheFile.parentFile?.mkdirs()
+
+        _isDownloading.value = true
+        return try {
+            cacheFile.outputStream().use { out ->
+                provider.downloadFile("${pair.remotePath}/${file.relativePath}", out) { }.getOrThrow()
+            }
+            MediaScannerConnection.scanFile(context, arrayOf(cacheFile.absolutePath), null, null)
+            cacheFile
+        } catch (e: Exception) {
+            Timber.e(e, "Download for preview failed: ${file.relativePath}")
+            cacheFile.delete()
+            _fileAction.emit(FileAction.Error("Download failed: ${e.message}"))
+            null
+        } finally {
+            _isDownloading.value = false
+        }
+    }
+
+    // ── Path resolution ───────────────────────────────────────────────────────
+
+    private fun resolveFile(file: SyncFileStateEntity, emitErrorIfMissing: Boolean = true): File? {
+        // Guard against path traversal from untrusted server responses
+        if (file.relativePath.contains("..")) {
+            viewModelScope.launch { _fileAction.emit(FileAction.Error("Invalid file path")) }
+            return null
+        }
+        val pair = selectedPair.value ?: return null
+        val root = safTreeUriToRealPath(pair.localPath) ?: pair.localPath
+        // localPath is a content:// URI we couldn't resolve — File-based access won't work
+        if (root.startsWith("content://")) return null
+        val f = File(root, file.relativePath)
+        if (!f.exists()) {
+            if (emitErrorIfMissing) {
+                viewModelScope.launch { _fileAction.emit(FileAction.Error("File not found on device")) }
+            }
+            return null
+        }
+        return f
+    }
+
+    private fun safTreeUriToRealPath(uriString: String): String? {
+        if (!uriString.startsWith("content://")) return uriString
+        return try {
+            val treeUri = android.net.Uri.parse(uriString)
+            val docId = android.provider.DocumentsContract.getTreeDocumentId(treeUri)
+            if (docId.startsWith("primary:")) "/storage/emulated/0/${docId.removePrefix("primary:")}"
+            else null
+        } catch (e: Exception) { null }
+    }
+}

app/src/main/kotlin/com/syncflow/ui/log/LogScreen.kt

@@ -6,16 +6,15 @@ 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.graphics.Color
-import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.syncflow.domain.model.SyncEventType
+import com.syncflow.ui.shared.iconAndTint
+import com.syncflow.ui.shared.label
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
@@ -143,31 +142,6 @@ private fun LogEntryRow(entry: LogEntry) {
     }
 }
 
-@Composable
-private fun SyncEventType.iconAndTint(): Pair<ImageVector, Color> = when (this) {
-    SyncEventType.SYNC_STARTED     -> Icons.Default.Sync to MaterialTheme.colorScheme.secondary
-    SyncEventType.SYNC_COMPLETED   -> Icons.Default.CheckCircle to MaterialTheme.colorScheme.primary
-    SyncEventType.SYNC_FAILED      -> Icons.Default.Error to MaterialTheme.colorScheme.error
-    SyncEventType.FILE_UPLOADED    -> Icons.Default.CloudUpload to MaterialTheme.colorScheme.secondary
-    SyncEventType.FILE_DOWNLOADED  -> Icons.Default.CloudDownload to MaterialTheme.colorScheme.secondary
-    SyncEventType.FILE_DELETED     -> Icons.Default.DeleteForever to MaterialTheme.colorScheme.tertiary
-    SyncEventType.FILE_SKIPPED     -> Icons.Outlined.Circle to MaterialTheme.colorScheme.onSurfaceVariant
-    SyncEventType.CONFLICT_DETECTED -> Icons.Default.Warning to MaterialTheme.colorScheme.tertiary
-    SyncEventType.CONFLICT_RESOLVED -> Icons.Default.CheckCircle to MaterialTheme.colorScheme.primary
-}
-
-private fun SyncEventType.label(): String = when (this) {
-    SyncEventType.SYNC_STARTED      -> "Sync started"
-    SyncEventType.SYNC_COMPLETED    -> "Sync completed"
-    SyncEventType.SYNC_FAILED       -> "Sync failed"
-    SyncEventType.FILE_UPLOADED     -> "File uploaded"
-    SyncEventType.FILE_DOWNLOADED   -> "File downloaded"
-    SyncEventType.FILE_DELETED      -> "File deleted"
-    SyncEventType.FILE_SKIPPED      -> "File skipped"
-    SyncEventType.CONFLICT_DETECTED -> "Conflict detected"
-    SyncEventType.CONFLICT_RESOLVED -> "Conflict resolved"
-}
-
 private fun java.time.LocalDate.toRelativeLabel(): String {
     val today = java.time.LocalDate.now()
     return when {

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

@@ -19,9 +19,11 @@ import androidx.compose.foundation.pager.HorizontalPager
 import androidx.compose.foundation.pager.rememberPagerState
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Folder
 import androidx.compose.material.icons.filled.ManageAccounts
 import androidx.compose.material.icons.filled.Notifications
 import androidx.compose.material.icons.filled.Sync
+import androidx.compose.material.icons.outlined.FolderOpen
 import androidx.compose.material.icons.outlined.ManageAccounts
 import androidx.compose.material.icons.outlined.NotificationsNone
 import androidx.compose.material.icons.outlined.Sync
@@ -33,6 +35,7 @@ import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.unit.dp
 import com.syncflow.R
+import com.syncflow.ui.files.FilesScreen
 import com.syncflow.ui.home.HomeScreen
 import com.syncflow.ui.log.LogScreen
 import com.syncflow.ui.settings.SettingsScreen
@@ -45,7 +48,7 @@ fun MainShell(
     onPairClick: (Long) -> Unit,
     onAddAccount: () -> Unit,
 ) {
-    val pagerState = rememberPagerState(pageCount = { 3 })
+    val pagerState = rememberPagerState(pageCount = { 4 })
     val scope = rememberCoroutineScope()
     val currentPage = pagerState.currentPage
 
@@ -102,7 +105,18 @@ fun MainShell(
                     onClick = { scope.launch { pagerState.animateScrollToPage(2) } },
                     icon = {
                         Icon(
-                            if (currentPage == 2) Icons.Filled.ManageAccounts else Icons.Outlined.ManageAccounts,
+                            if (currentPage == 2) Icons.Filled.Folder else Icons.Outlined.FolderOpen,
+                            contentDescription = null,
+                        )
+                    },
+                    label = { Text("Files") },
+                )
+                NavigationBarItem(
+                    selected = currentPage == 3,
+                    onClick = { scope.launch { pagerState.animateScrollToPage(3) } },
+                    icon = {
+                        Icon(
+                            if (currentPage == 3) Icons.Filled.ManageAccounts else Icons.Outlined.ManageAccounts,
                             contentDescription = null,
                         )
                     },
@@ -135,7 +149,8 @@ fun MainShell(
             when (page) {
                 0 -> HomeScreen(onAddPair = onAddPair, onPairClick = onPairClick)
                 1 -> LogScreen()
-                2 -> SettingsScreen(onAddAccount = onAddAccount)
+                2 -> FilesScreen()
+                3 -> SettingsScreen(onAddAccount = onAddAccount)
             }
         }
     }

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

@@ -17,14 +17,12 @@ 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 com.syncflow.ui.shared.SyncEventRow
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
@@ -132,7 +130,7 @@ fun PairDetailScreen(
                 }
             } else {
                 items(events, key = { it.id }) { event ->
-                    EventRow(event)
+                    SyncEventRow(event, showDivider = event != events.last())
                 }
             }
         }
@@ -231,56 +229,6 @@ private fun InfoRow(
     }
 }
 
-@Composable
-private fun EventRow(event: SyncEventEntity) {
-    val fmt = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)
-    val zone = ZoneId.systemDefault()
-    val dotColor = eventColor(event.eventType)
-    Row(
-        modifier = Modifier.fillMaxWidth().padding(vertical = 4.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        // 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,
-            )
-            event.message?.takeIf { event.filePath != null }?.let {
-                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,
-        )
-    }
-}
-
-@Composable
-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 }

app/src/main/kotlin/com/syncflow/ui/shared/SyncEventRow.kt

@@ -0,0 +1,102 @@
+package com.syncflow.ui.shared
+
+import androidx.compose.foundation.layout.*
+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.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.unit.dp
+import com.syncflow.data.db.entities.SyncEventEntity
+import com.syncflow.domain.model.SyncEventType
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+
+@Composable
+fun SyncEventRow(event: SyncEventEntity, showDivider: Boolean = true) {
+    val (icon, tint) = event.eventType.iconAndTint()
+    val timeFmt = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)
+    val timeStr = timeFmt.format(event.timestamp.atZone(ZoneId.systemDefault()))
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 10.dp),
+        verticalAlignment = Alignment.Top,
+    ) {
+        Surface(
+            shape = RoundedCornerShape(10.dp),
+            color = tint.copy(alpha = 0.12f),
+            modifier = Modifier.size(36.dp),
+        ) {
+            Box(contentAlignment = Alignment.Center) {
+                Icon(icon, contentDescription = null, Modifier.size(18.dp), tint = tint)
+            }
+        }
+        Spacer(Modifier.width(12.dp))
+        Column(modifier = Modifier.weight(1f)) {
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.SpaceBetween,
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                Text(
+                    event.eventType.label(),
+                    style = MaterialTheme.typography.labelMedium,
+                )
+                Text(
+                    timeStr,
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            val detail = event.filePath ?: event.message
+            if (detail != null) {
+                Spacer(Modifier.height(2.dp))
+                Text(
+                    text = detail,
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1,
+                )
+            }
+        }
+    }
+    if (showDivider) {
+        HorizontalDivider(
+            color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f),
+            modifier = Modifier.padding(start = 48.dp),
+        )
+    }
+}
+
+@Composable
+fun SyncEventType.iconAndTint(): Pair<ImageVector, Color> = when (this) {
+    SyncEventType.SYNC_STARTED     -> Icons.Default.Sync to MaterialTheme.colorScheme.secondary
+    SyncEventType.SYNC_COMPLETED   -> Icons.Default.CheckCircle to MaterialTheme.colorScheme.primary
+    SyncEventType.SYNC_FAILED      -> Icons.Default.Error to MaterialTheme.colorScheme.error
+    SyncEventType.FILE_UPLOADED    -> Icons.Default.CloudUpload to MaterialTheme.colorScheme.secondary
+    SyncEventType.FILE_DOWNLOADED  -> Icons.Default.CloudDownload to MaterialTheme.colorScheme.secondary
+    SyncEventType.FILE_DELETED     -> Icons.Default.DeleteForever to MaterialTheme.colorScheme.tertiary
+    SyncEventType.FILE_SKIPPED     -> Icons.Outlined.Circle to MaterialTheme.colorScheme.onSurfaceVariant
+    SyncEventType.CONFLICT_DETECTED -> Icons.Default.Warning to MaterialTheme.colorScheme.tertiary
+    SyncEventType.CONFLICT_RESOLVED -> Icons.Default.CheckCircle to MaterialTheme.colorScheme.primary
+}
+
+fun SyncEventType.label(): String = when (this) {
+    SyncEventType.SYNC_STARTED      -> "Sync started"
+    SyncEventType.SYNC_COMPLETED    -> "Sync completed"
+    SyncEventType.SYNC_FAILED       -> "Sync failed"
+    SyncEventType.FILE_UPLOADED     -> "File uploaded"
+    SyncEventType.FILE_DOWNLOADED   -> "File downloaded"
+    SyncEventType.FILE_DELETED      -> "File deleted"
+    SyncEventType.FILE_SKIPPED      -> "File skipped"
+    SyncEventType.CONFLICT_DETECTED -> "Conflict detected"
+    SyncEventType.CONFLICT_RESOLVED -> "Conflict resolved"
+}

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

@@ -2,27 +2,28 @@ package com.syncflow.ui.theme
 
 import androidx.compose.ui.graphics.Color
 
-// Primary — indigo
-val Indigo600  = Color(0xFF4F46E5)
-val Indigo900  = Color(0xFF312E81)
-val Indigo100  = Color(0xFFE0E7FF)
-val Indigo50   = Color(0xFFEEF2FF)
+// Primary — deep red (Passbolt-inspired)
+val Red900  = Color(0xFF7F0000)
+val Red700  = Color(0xFFB71C1C)
+val Red500  = Color(0xFFEF5350)
+val Red100  = Color(0xFFFFCDD2)
+val Red50   = Color(0xFFFFEBEE)
 
-// Secondary — teal
-val Teal600    = Color(0xFF0D9488)
-val Teal100    = Color(0xFFCCFBF1)
+// Secondary — deep orange
+val Orange700 = Color(0xFFE64A19)
+val Orange100 = Color(0xFFFBE9E7)
 
 // Tertiary — amber
-val Amber500   = Color(0xFFF59E0B)
-val Amber100   = Color(0xFFFEF3C7)
+val Amber500  = Color(0xFFFFB300)
+val Amber100  = Color(0xFFFFF8E1)
 
 // Neutrals
-val Slate50    = Color(0xFFF8FAFC)
-val Slate100   = Color(0xFFF1F5F9)
-val Slate200   = Color(0xFFE2E8F0)
-val Slate600   = Color(0xFF475569)
-val Slate900   = Color(0xFF0F172A)
+val Gray50   = Color(0xFFF8F9FA)
+val Gray100  = Color(0xFFF3F4F6)
+val Gray200  = Color(0xFFE5E7EB)
+val Gray600  = Color(0xFF6B7280)
+val Gray900  = Color(0xFF111827)
 
 // Semantic
-val GreenSuccess = Color(0xFF16A34A)
-val RedError     = Color(0xFFDC2626)
+val GreenSuccess = Color(0xFF2E7D32)
+val RedError     = Color(0xFFEF5350)

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

@@ -13,41 +13,43 @@ import androidx.compose.ui.unit.sp
 import androidx.core.view.WindowCompat
 
 private val LightColors = lightColorScheme(
-    primary            = Indigo600,
+    primary            = Red700,
     onPrimary          = Color.White,
-    primaryContainer   = Indigo100,
-    onPrimaryContainer = Indigo900,
-    secondary          = Teal600,
+    primaryContainer   = Red50,
+    onPrimaryContainer = Red900,
+    secondary          = Orange700,
     onSecondary        = Color.White,
-    secondaryContainer = Teal100,
+    secondaryContainer = Orange100,
     tertiary           = Amber500,
     tertiaryContainer  = Amber100,
-    background         = Slate50,
+    background         = Gray50,
     surface            = Color.White,
-    surfaceVariant     = Slate100,
-    onSurfaceVariant   = Slate600,
+    surfaceVariant     = Gray100,
+    onSurface          = Gray900,
+    onSurfaceVariant   = Gray600,
     error              = RedError,
-    errorContainer     = Color(0xFFFEE2E2),
-    outline            = Slate200,
+    errorContainer     = Red50,
+    outline            = Gray200,
 )
 
 private val DarkColors = darkColorScheme(
-    primary            = Color(0xFF818CF8),
-    onPrimary          = Indigo900,
-    primaryContainer   = Color(0xFF3730A3),
-    onPrimaryContainer = Indigo100,
-    secondary          = Color(0xFF2DD4BF),
-    onSecondary        = Color(0xFF003731),
-    secondaryContainer = Color(0xFF00504A),
+    primary            = Red500,
+    onPrimary          = Color.White,
+    primaryContainer   = Red900,
+    onPrimaryContainer = Red100,
+    secondary          = Color(0xFFFF7043),
+    onSecondary        = Color.White,
+    secondaryContainer = Color(0xFF4E1500),
     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),
+    tertiaryContainer  = Color(0xFF3E2700),
+    background         = Color(0xFF0F0F0F),
+    surface            = Color(0xFF1C1C1C),
+    surfaceVariant     = Color(0xFF2A2A2A),
+    onSurface          = Color(0xFFEAEAEA),
+    onSurfaceVariant   = Color(0xFF9E9E9E),
+    error              = Color(0xFFFF5252),
+    errorContainer     = Color(0xFF5C0000),
+    outline            = Color(0xFF3D3D3D),
 )
 
 private val AppTypography = Typography(

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

@@ -18,7 +18,8 @@ class BootReceiver : BroadcastReceiver() {
     @Inject lateinit var syncPairDao: SyncPairDao
 
     override fun onReceive(context: Context, intent: Intent) {
-        if (intent.action != Intent.ACTION_BOOT_COMPLETED) return
+        val validActions = setOf(Intent.ACTION_BOOT_COMPLETED, Intent.ACTION_MY_PACKAGE_REPLACED)
+        if (intent.action !in validActions) return
         val wm = WorkManager.getInstance(context)
         val pending = goAsync()
         CoroutineScope(Dispatchers.IO).launch {

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

@@ -13,13 +13,18 @@ import android.os.Looper
 import android.provider.DocumentsContract
 import androidx.core.app.NotificationCompat
 import androidx.work.ExistingWorkPolicy
+import androidx.work.WorkInfo
 import androidx.work.WorkManager
+import kotlinx.coroutines.flow.first
 import com.syncflow.MainActivity
 import com.syncflow.R
+import com.syncflow.data.db.SyncFileStateDao
 import com.syncflow.data.db.SyncPairDao
 import com.syncflow.domain.model.ScheduleType
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import timber.log.Timber
 import java.io.File
 import javax.inject.Inject
@@ -28,13 +33,22 @@ import javax.inject.Inject
 class FileWatchService : Service() {
 
     @Inject lateinit var syncPairDao: SyncPairDao
+    @Inject lateinit var fileStateDao: SyncFileStateDao
 
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private val mainHandler = Handler(Looper.getMainLooper())
+    // Prevents concurrent refresh() calls from doubling watchers + catchup scans
+    private val refreshMutex = Mutex()
 
-    private val fileObservers = mutableMapOf<Long, FileObserver>()
+    // Multiple FileObserver instances per pair: one per directory (recursive)
+    private val fileObservers = mutableMapOf<Long, MutableList<FileObserver>>()
     private val contentObservers = mutableMapOf<Long, ContentObserver>()
     private val debounceJobs = mutableMapOf<Long, Job>()
+    // Persistent monitors that watch WorkManager for ANY sync (manual, catchup, onchange)
+    // so the cooldown is set regardless of who triggered the sync.
+    private val syncMonitorJobs = mutableMapOf<Long, Job>()
+    // After a sync completes, suppress FileObserver events for this long.
+    private val syncCooldownUntil = mutableMapOf<Long, Long>()
 
     companion object {
         const val CHANNEL_WATCH = "sync_watching"
@@ -73,7 +87,7 @@ class FileWatchService : Service() {
 
     override fun onBind(intent: Intent?): IBinder? = null
 
-    private suspend fun refresh() {
+    private suspend fun refresh() = refreshMutex.withLock {
         clearWatchers()
         val pairs = syncPairDao.getEnabled().filter { it.scheduleType == ScheduleType.ON_CHANGE }
 
@@ -104,7 +118,7 @@ class FileWatchService : Service() {
             }
         }
 
-        val count = fileObservers.size + contentObservers.size
+        val count = fileObservers.keys.size + contentObservers.size
         updateNotification(count)
 
         if (count == 0) {
@@ -136,43 +150,185 @@ class FileWatchService : Service() {
             Timber.w("FileWatchService: path does not exist for pair $pairId: $path")
             return
         }
+        fileObservers[pairId] = mutableListOf()
+        // Set startup cooldown BEFORE registering watchers so inotify events that fire
+        // immediately on registration don't trigger the debounce before catchupScan runs.
+        syncCooldownUntil[pairId] = System.currentTimeMillis() + 15_000
+        watchDirRecursive(dir, pairId, wifiOnly, chargingOnly)
+        Timber.d("FileWatchService: watching pair $pairId at $path (${fileObservers[pairId]?.size} dirs)")
+        startSyncMonitor(pairId)
+        scope.launch { catchupScan(pairId, dir, wifiOnly, chargingOnly) }
+    }
+
+    // Watches WorkManager for ANY sync tagged sync_$pairId (manual, catchup, onchange).
+    // Sets cooldown while running and for 60s after, so FileObserver events from our
+    // own file writes never trigger a re-sync regardless of what started the sync.
+    private fun startSyncMonitor(pairId: Long) {
+        syncMonitorJobs[pairId]?.cancel()
+        syncMonitorJobs[pairId] = scope.launch {
+            var wasSyncing = false
+            WorkManager.getInstance(applicationContext)
+                .getWorkInfosByTagFlow("sync_$pairId")
+                .collect { infos ->
+                    val isSyncing = infos.any {
+                        it.state == WorkInfo.State.RUNNING || it.state == WorkInfo.State.ENQUEUED
+                    }
+                    if (isSyncing) {
+                        Timber.d("FileWatchService: sync active for pair $pairId — cooldown extended")
+                        syncCooldownUntil[pairId] = System.currentTimeMillis() + 120_000
+                        wasSyncing = true
+                    } else if (wasSyncing) {
+                        Timber.d("FileWatchService: sync finished for pair $pairId — 60s settle cooldown")
+                        syncCooldownUntil[pairId] = System.currentTimeMillis() + 60_000
+                        wasSyncing = false
+                    }
+                }
+        }
+    }
+
+    private fun watchDirRecursive(dir: File, pairId: Long, wifiOnly: Boolean, chargingOnly: Boolean) {
+        if (!dir.isDirectory) return
         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, p: String?) = onChangeDetected(pairId, wifiOnly, chargingOnly)
+                override fun onEvent(event: Int, path: String?) {
+                    if (event and FileObserver.CREATE != 0 && path != null) {
+                        val created = File(dir, path)
+                        if (created.isDirectory) watchDirRecursive(created, pairId, wifiOnly, chargingOnly)
+                    }
+                    onChangeDetected(pairId, wifiOnly, chargingOnly)
+                }
             }
         } else {
             @Suppress("DEPRECATION")
-            object : FileObserver(path, mask) {
-                override fun onEvent(event: Int, p: String?) = onChangeDetected(pairId, wifiOnly, chargingOnly)
+            object : FileObserver(dir.absolutePath, mask) {
+                override fun onEvent(event: Int, path: String?) {
+                    if (event and FileObserver.CREATE != 0 && path != null) {
+                        val created = File(dir, path)
+                        if (created.isDirectory) watchDirRecursive(created, pairId, wifiOnly, chargingOnly)
+                    }
+                    onChangeDetected(pairId, wifiOnly, chargingOnly)
+                }
             }
         }
         observer.startWatching()
-        fileObservers[pairId] = observer
-        Timber.d("FileWatchService: watching filesystem path for pair $pairId: $path")
+        fileObservers.getOrPut(pairId) { mutableListOf() }.add(observer)
+        // Recursively watch existing subdirectories
+        dir.listFiles()?.filter { it.isDirectory }?.forEach { sub ->
+            watchDirRecursive(sub, pairId, wifiOnly, chargingOnly)
+        }
+    }
+
+    private suspend fun catchupScan(pairId: Long, dir: File, wifiOnly: Boolean, chargingOnly: Boolean) {
+        val known = fileStateDao.getForPair(pairId).associateBy { it.relativePath }
+        if (known.isEmpty()) return // Never synced — first sync will be triggered manually
+
+        val current = mutableMapOf<String, Long>()
+        dir.walk().filter { it.isFile }.forEach { f ->
+            current[f.relativeTo(dir).path.replace('\\', '/')] = f.lastModified()
+        }
+
+        val hasNew      = current.any { (rel, _) -> rel !in known }
+        val hasModified = current.any { (rel, mtime) ->
+            val s = known[rel]; s != null && s.localModifiedAt != null &&
+            s.localModifiedAt.toEpochMilli() != mtime
+        }
+        val hasDeleted  = known.keys.any { rel -> rel !in current }
+
+        if (hasNew || hasModified || hasDeleted) {
+            Timber.d("FileWatchService: catchup detected changes for pair $pairId, scheduling sync")
+            val pair = syncPairDao.getById(pairId) ?: return
+            // Cancel any debounce that started before our startup cooldown was set
+            debounceJobs[pairId]?.cancel()
+            debounceJobs.remove(pairId)
+            // Hold cooldown for duration of sync + 60s settle
+            syncCooldownUntil[pairId] = System.currentTimeMillis() + 120_000
+            val req = SyncWorker.buildOneTimeRequest(pairId, wifiOnly, chargingOnly)
+            WorkManager.getInstance(applicationContext)
+                .enqueueUniqueWork("catchup_$pairId", ExistingWorkPolicy.KEEP, req)
+            scope.launch {
+                try {
+                    WorkManager.getInstance(applicationContext)
+                        .getWorkInfoByIdFlow(req.id)
+                        .first { it?.state?.isFinished == true }
+                    syncCooldownUntil[pairId] = System.currentTimeMillis() + 60_000
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (_: Exception) {
+                    syncCooldownUntil[pairId] = System.currentTimeMillis() + 60_000
+                }
+            }
+        }
     }
 
     private fun onChangeDetected(pairId: Long, wifiOnly: Boolean, chargingOnly: Boolean) {
+        // Ignore events fired by our own sync writing files — prevents the feedback loop
+        // where downloaded/uploaded files trigger another sync indefinitely.
+        if (System.currentTimeMillis() < (syncCooldownUntil[pairId] ?: 0L)) {
+            Timber.d("FileWatchService: suppressing change event for pair $pairId (sync cooldown)")
+            return
+        }
+
         debounceJobs[pairId]?.cancel()
         debounceJobs[pairId] = scope.launch {
             delay(5_000)
+            // Re-check: catchupScan or another path may have already set a cooldown
+            // and handled this sync while we were waiting.
+            if (System.currentTimeMillis() < (syncCooldownUntil[pairId] ?: 0L)) {
+                Timber.d("FileWatchService: debounce fired but cooldown active for pair $pairId, skipping")
+                return@launch
+            }
             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)
+
+            // Block new triggers from this point until 60s after sync completes
+            syncCooldownUntil[pairId] = System.currentTimeMillis() + 120_000
+
+            val req = SyncWorker.buildOneTimeRequest(pairId, wifiOnly, chargingOnly, silent = true)
             WorkManager.getInstance(applicationContext)
                 .enqueueUniqueWork("onchange_$pairId", ExistingWorkPolicy.KEEP, req)
+
+            updateNotificationDynamic("Syncing: ${pair.name}…")
+
+            scope.launch {
+                try {
+                    val info = WorkManager.getInstance(applicationContext)
+                        .getWorkInfoByIdFlow(req.id)
+                        .first { it?.state?.isFinished == true }
+                    // Extend cooldown: 60s after sync finishes to let filesystem settle
+                    syncCooldownUntil[pairId] = System.currentTimeMillis() + 60_000
+                    val summary = info?.outputData?.getString(SyncWorker.KEY_RESULT_SUMMARY)
+                    val watchCount = fileObservers.keys.size + contentObservers.size
+                    val watching = "Watching $watchCount folder${if (watchCount != 1) "s" else ""}"
+                    if (info?.state == WorkInfo.State.SUCCEEDED && summary != null) {
+                        updateNotificationDynamic("${pair.name}: $summary — $watching")
+                    } else {
+                        updateNotificationDynamic("$watching")
+                    }
+                    delay(12_000)
+                    updateNotificationDynamic(null)
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (_: Exception) {
+                    syncCooldownUntil[pairId] = System.currentTimeMillis() + 60_000
+                    updateNotificationDynamic(null)
+                }
+            }
         }
     }
 
     private fun clearWatchers() {
-        fileObservers.values.forEach { it.stopWatching() }
+        fileObservers.values.flatten().forEach { it.stopWatching() }
         fileObservers.clear()
         contentObservers.values.forEach { contentResolver.unregisterContentObserver(it) }
         contentObservers.clear()
         debounceJobs.values.forEach { it.cancel() }
         debounceJobs.clear()
+        syncMonitorJobs.values.forEach { it.cancel() }
+        syncMonitorJobs.clear()
+        syncCooldownUntil.clear()
     }
 
     private fun ensureChannel() {
@@ -187,7 +343,7 @@ class FileWatchService : Service() {
         }
     }
 
-    private fun buildNotification(count: Int): Notification {
+    private fun buildNotification(count: Int, overrideText: String? = null): Notification {
         val tapIntent = PendingIntent.getActivity(
             this, 0,
             Intent(this, MainActivity::class.java).apply { flags = Intent.FLAG_ACTIVITY_SINGLE_TOP },
@@ -196,7 +352,7 @@ class FileWatchService : Service() {
         return NotificationCompat.Builder(this, CHANNEL_WATCH)
             .setContentTitle("SyncFlow")
             .setContentText(
-                if (count > 0) "Watching $count folder${if (count != 1) "s" else ""} for changes"
+                overrideText ?: if (count > 0) "Watching $count folder${if (count != 1) "s" else ""} for changes"
                 else "Starting file watcher…"
             )
             .setSmallIcon(R.drawable.ic_sync)
@@ -210,4 +366,10 @@ class FileWatchService : Service() {
         val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
         nm.notify(NOTIFICATION_ID, buildNotification(count))
     }
+
+    private fun updateNotificationDynamic(overrideText: String?) {
+        val count = fileObservers.keys.size + contentObservers.size
+        val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        nm.notify(NOTIFICATION_ID, buildNotification(count, overrideText))
+    }
 }

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

@@ -39,6 +39,8 @@ class SyncWorker @AssistedInject constructor(
         val pair = syncPairDao.getById(pairId) ?: return Result.failure()
         val account = accountRepository.getAccount(pair.accountId) ?: return Result.failure()
 
+        val silent = inputData.getBoolean(KEY_SILENT, false)
+
         ensureChannels()
         setForeground(buildForegroundInfo(pair.name, "Syncing…"))
 
@@ -47,7 +49,15 @@ class SyncWorker @AssistedInject constructor(
             val provider = providerFactory.create(account)
             val result = syncEngine.sync(domainPair, provider)
 
-            if (result.error != null && pair.notifyOnError) {
+            val lines = buildList {
+                if (result.uploaded > 0)   add("↑${result.uploaded}")
+                if (result.downloaded > 0) add("↓${result.downloaded}")
+                if (result.deleted > 0)    add("🗑${result.deleted}")
+                if (result.conflicts > 0)  add("⚠${result.conflicts}")
+            }
+            val resultSummary = if (lines.isEmpty()) "Up to date" else lines.joinToString(" ")
+
+            if (!silent && result.error != null && pair.notifyOnError) {
                 notify(
                     id = pairId.toInt() + RESULT_ID_OFFSET,
                     channelId = CHANNEL_ALERTS,
@@ -55,28 +65,28 @@ class SyncWorker @AssistedInject constructor(
                     text = result.error.message ?: "Unknown error",
                     priority = NotificationCompat.PRIORITY_DEFAULT,
                 )
-            } else if (pair.notifyOnComplete && result.error == null) {
-                val lines = buildList {
+            } else if (!silent && pair.notifyOnComplete && result.error == null) {
+                val fullLines = 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")
+                val summary = if (fullLines.isEmpty()) "Up to date — nothing to sync" else fullLines.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(),
+                    title = "${pair.name} — Synced",
+                    text = if (fullLines.isEmpty()) summary else fullLines.first(),
                     bigText = summary,
                     priority = NotificationCompat.PRIORITY_LOW,
                 )
             }
 
-            Result.success()
+            Result.success(workDataOf(KEY_RESULT_SUMMARY to resultSummary))
         } catch (e: Exception) {
             Timber.e(e, "SyncWorker failed for pair $pairId")
-            if (pair.notifyOnError) {
+            if (!silent && pair.notifyOnError) {
                 notify(
                     id = pairId.toInt() + RESULT_ID_OFFSET,
                     channelId = CHANNEL_ALERTS,
@@ -146,19 +156,21 @@ class SyncWorker @AssistedInject constructor(
 
     companion object {
         const val KEY_PAIR_ID = "pair_id"
+        const val KEY_SILENT = "silent"
+        const val KEY_RESULT_SUMMARY = "result_summary"
         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 {
+        fun buildOneTimeRequest(pairId: Long, wifiOnly: Boolean, chargingOnly: Boolean, silent: Boolean = false): OneTimeWorkRequest {
             val constraints = Constraints.Builder()
                 .setRequiredNetworkType(if (wifiOnly) NetworkType.UNMETERED else NetworkType.CONNECTED)
                 .setRequiresCharging(chargingOnly)
                 .build()
             return OneTimeWorkRequestBuilder<SyncWorker>()
-                .setInputData(workDataOf(KEY_PAIR_ID to pairId))
+                .setInputData(workDataOf(KEY_PAIR_ID to pairId, KEY_SILENT to silent))
                 .setConstraints(constraints)
                 .setBackoffCriteria(BackoffPolicy.EXPONENTIAL, 30, TimeUnit.SECONDS)
                 .addTag("sync_$pairId")

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

@@ -1,9 +1,12 @@
 <?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>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+
+    <!-- Pure black background -->
+    <path android:pathData="M0,0 H108 V108 H0 Z"
+        android:fillColor="#000000"/>
+
+</vector>

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

@@ -1,70 +1,84 @@
 <?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 -->
+    <!--
+      Four thick arcs arranged as an interlocked pinwheel.
+      Each arc sweeps ~210 degrees, rounded caps, radius 18 from center (54,54).
+      Draw order creates natural over/under at the four crossing points:
+        blue under green, green under red, red under orange, orange under blue (re-draw blue tip).
+
+      Arc endpoints computed at radius 18, sweep 210 deg clockwise:
+        start angle  end angle    start point    end point
+        270 (top)    120          (54, 36)        (45, 70)
+          0 (right)  210          (72, 54)        (39, 45)
+         90 (bot)    300          (54, 72)        (63, 38)
+        180 (left)   390=30       (36, 54)        (69, 63)
+    -->
+
+    <!-- Blue — starts at top, sweeps clockwise to lower-left -->
     <path
-        android:pathData="M54,54m-44,0a44,44 0 1,0 88,0a44,44 0 1,0 -88,0"
-        android:fillColor="#12FFFFFF"/>
+        android:strokeColor="#2979FF"
+        android:strokeWidth="8.5"
+        android:fillColor="#00000000"
+        android:strokeLineCap="round"
+        android:pathData="M 54,36 A 18,18 0 1,1 45,70"/>
 
-    <!-- Mid glow ring -->
+    <!-- Green — starts at bottom, sweeps clockwise to upper-right -->
     <path
-        android:pathData="M54,54m-33,0a33,33 0 1,0 66,0a33,33 0 1,0 -66,0"
-        android:fillColor="#18FFFFFF"/>
+        android:strokeColor="#00C853"
+        android:strokeWidth="8.5"
+        android:fillColor="#00000000"
+        android:strokeLineCap="round"
+        android:pathData="M 54,72 A 18,18 0 1,1 63,38"/>
 
-    <!-- Inner glow ring -->
+    <!-- Red — starts at right, sweeps clockwise to lower-left -->
     <path
-        android:pathData="M54,54m-21,0a21,21 0 1,0 42,0a21,21 0 1,0 -42,0"
-        android:fillColor="#10FFFFFF"/>
+        android:strokeColor="#E53935"
+        android:strokeWidth="8.5"
+        android:fillColor="#00000000"
+        android:strokeLineCap="round"
+        android:pathData="M 72,54 A 18,18 0 1,1 39,45"/>
 
-    <!-- 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 -->
+    <!-- Orange — starts at left, sweeps clockwise to upper-right -->
     <path
-        android:pathData="M54,54m-7,0a7,7 0 1,0 14,0a7,7 0 1,0 -14,0"
-        android:fillColor="#60FFFFFF"/>
+        android:strokeColor="#FF6D00"
+        android:strokeWidth="8.5"
+        android:fillColor="#00000000"
+        android:strokeLineCap="round"
+        android:pathData="M 36,54 A 18,18 0 1,1 69,63"/>
+
+    <!-- Re-draw blue start cap on top so it goes OVER orange end -->
     <path
-        android:pathData="M54,54m-4,0a4,4 0 1,0 8,0a4,4 0 1,0 -8,0"
-        android:fillColor="#FFFFFF"/>
+        android:strokeColor="#2979FF"
+        android:strokeWidth="8.5"
+        android:fillColor="#00000000"
+        android:strokeLineCap="round"
+        android:pathData="M 54,36 A 18,18 0 0,1 62,37.5"/>
 
-    <!-- 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"/>
+    <!-- White sync circle at center -->
+    <path
+        android:fillColor="#000000"
+        android:pathData="M 45,54 A 9,9 0 1,0 63,54 A 9,9 0 1,0 45,54 Z"/>
 
-    <!-- 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"/>
+    <!-- Sync ring -->
+    <path
+        android:strokeColor="#FFFFFF"
+        android:strokeWidth="2.5"
+        android:fillColor="#00000000"
+        android:pathData="M 46.5,54 A 7.5,7.5 0 1,0 61.5,54 A 7.5,7.5 0 1,0 46.5,54 Z"/>
+
+    <!-- Top arrow head (pointing up) -->
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M 54,46.5 L 57,50.5 L 51,50.5 Z"/>
+
+    <!-- Bottom arrow head (pointing down) -->
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M 54,61.5 L 51,57.5 L 57,57.5 Z"/>
 
 </vector>

app/src/main/res/xml/file_paths.xml

@@ -1,5 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <paths>
+    <external-path name="external_storage" path="." />
     <external-files-path name="external_files" path="." />
     <files-path name="internal_files" path="." />
+    <cache-path name="syncflow_cache" path="syncflow_open/" />
 </paths>

version.properties

@@ -1,2 +1,2 @@
-VERSION_NAME=1.0.21
-VERSION_CODE=22
+VERSION_NAME=1.0.32
+VERSION_CODE=33