v1.0.71: SFTP connection pooling — reuse SSH session across all operations

Previously every listFiles/uploadFile/downloadFile/deleteFile call created
a fresh SSH connection (connect → auth → use → disconnect). For zahra's
folder with 69 subdirectories, the recursive listing alone made 70 full
SSH handshakes, then one more per downloaded file — causing connection
timeouts and 65 upload/download failures reported as PARTIAL.

Now the provider holds a persistent SSH session and reuses it for all
calls, reconnecting automatically if the connection drops.

.gitea/workflows/release.yml

@@ -0,0 +1,81 @@
+name: Build & Release APK
+
+on:
+  push:
+    branches: ['**']
+    tags:
+      - 'v*'
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write   # needed to create the release object on a tag
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: gradle
+
+      - uses: android-actions/setup-android@v3
+
+      - name: Run unit tests
+        run: |
+          chmod +x gradlew
+          ./gradlew testDebugUnitTest --no-daemon
+
+      - name: Decode release keystore
+        env:
+          KEYSTORE_BASE64: ${{ secrets.KEYSTORE_BASE64 }}
+        run: |
+          if [ -n "$KEYSTORE_BASE64" ]; then
+            echo "$KEYSTORE_BASE64" | base64 -d > "$RUNNER_TEMP/release.keystore"
+            echo "KEYSTORE_PATH=$RUNNER_TEMP/release.keystore" >> "$GITHUB_ENV"
+            echo "Release keystore decoded — building signed release."
+          else
+            echo "::warning::KEYSTORE_BASE64 secret not set — release APK will be debug-signed."
+          fi
+
+      - name: Build release APK
+        env:
+          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
+          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
+          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+        run: ./gradlew assembleRelease --no-daemon
+
+      - name: Get version name
+        id: ver
+        run: echo "name=$(grep VERSION_NAME version.properties | cut -d= -f2)" >> $GITHUB_OUTPUT
+
+      - name: Rename APK
+        run: |
+          mkdir dist
+          cp app/build/outputs/apk/release/app-release.apk \
+             dist/SyncFlow-v${{ steps.ver.outputs.name }}.apk
+
+      - name: Attach APK to release
+        if: startsWith(github.ref, 'refs/tags/v')
+        env:
+          TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ github.ref_name }}
+          VERSION: ${{ steps.ver.outputs.name }}
+        run: |
+          API="https://gitea.khodak.me/api/v1/repos/amir/SyncFlow"
+          # A pushed git tag does NOT create a Gitea release object — fetch it, create if missing.
+          RELEASE_ID=$(curl -s "$API/releases/tags/$TAG" -H "Authorization: token $TOKEN" \
+            | python3 -c "import sys,json;d=json.load(sys.stdin);print(d.get('id','') if isinstance(d,dict) else '')" 2>/dev/null)
+          if [ -z "$RELEASE_ID" ]; then
+            RELEASE_ID=$(curl -s -X POST "$API/releases" -H "Authorization: token $TOKEN" \
+              -H "Content-Type: application/json" -d "{\"tag_name\":\"$TAG\",\"name\":\"$TAG\"}" \
+              | python3 -c "import sys,json;print(json.load(sys.stdin).get('id',''))")
+            echo "created release object $RELEASE_ID for $TAG"
+          fi
+          curl -sf -X POST "$API/releases/$RELEASE_ID/assets?name=SyncFlow-v${VERSION}.apk" \
+            -H "Authorization: token $TOKEN" \
+            -F "attachment=@dist/SyncFlow-v${VERSION}.apk"
+          echo "APK uploaded to release $TAG (id $RELEASE_ID)"

.gitignore

@@ -1,5 +1,6 @@
 *.iml
 .gradle/
+.kotlin/
 local.properties
 .idea/
 .DS_Store

LICENSE

@@ -0,0 +1,40 @@
+SyncFlow Source-Available License
+Copyright (c) 2026 Amir Khodak. All rights reserved.
+
+This is NOT an OSI-approved open-source license. The source code is made
+publicly viewable ("source-available"), but the rights granted are limited as
+described below. Where this license is silent, all rights are reserved.
+
+1. DEFINITIONS
+   "Software" means the SyncFlow source code, assets, and documentation in this
+   repository. "You" means anyone other than the copyright holder.
+
+2. WHAT YOU MAY DO
+   a. View, read, and study the Software.
+   b. Clone or fork the repository for your own private, personal,
+      non-commercial use and experimentation.
+   c. Build the Software from source and run it on devices you personally own.
+   d. Submit contributions (pull requests) back to this repository; by doing so
+      you license your contribution to the copyright holder under these terms.
+
+3. WHAT YOU MAY NOT DO (without the copyright holder's prior written permission)
+   a. Redistribute, publish, or make available the Software or any derivative
+      work — in source or binary/APK form — to any third party or app store
+      (including but not limited to Google Play, F-Droid, Amazon Appstore,
+      Gitea/GitHub releases, or any website).
+   b. Use the Software, in whole or in part, for any commercial purpose.
+   c. Sell, sublicense, rent, or offer the Software as a service.
+   d. Use the names, app identity ("SyncFlow"), package identifier
+      ("com.syncflow"), logos, or signing keys of the original work.
+   e. Remove or alter this license or the copyright notice.
+
+4. RESERVED RIGHTS
+   All publishing and distribution rights are reserved exclusively to the
+   copyright holder. Only the copyright holder may publish official builds.
+
+5. NO WARRANTY
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM,
+   DAMAGES, OR OTHER LIABILITY ARISING FROM THE SOFTWARE OR ITS USE.
+
+To request permission for anything in section 3, contact the copyright holder.

README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <img src="app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png" width="108" alt="SyncFlow">
+</p>
+
 # SyncFlow
 
 Native Android file sync app — sync any folder to WebDAV, SFTP, Nextcloud, ownCloud, Google Drive, Dropbox, or OneDrive.
@@ -36,3 +40,10 @@ Native Android file sync app — sync any folder to WebDAV, SFTP, Nextcloud, own
 
 - Android 8.0+ (API 26)
 - Storage permission (or SAF picker) for local folder access
+
+## License
+
+SyncFlow is **source-available, not open-source** — see [LICENSE](LICENSE).
+You may read, study, and fork it for personal, non-commercial use, but
+**redistributing or publishing the app (source or APK) is not permitted**.
+Only the copyright holder publishes official, signed builds.

app/build.gradle.kts

@@ -18,16 +18,25 @@ val localProps = Properties().apply {
     if (f.exists()) load(f.inputStream())
 }
 
+// Release signing is read from local.properties (local builds) or environment variables
+// (CI). When no keystore is available the release build falls back to the debug key so the
+// build still succeeds — it just isn't a distributable, properly-signed APK.
+val keystorePath = (localProps["KEYSTORE_PATH"] as String?) ?: System.getenv("KEYSTORE_PATH")
+val hasReleaseKeystore = keystorePath != null && file(keystorePath).exists()
+
 android {
     namespace = "com.syncflow"
-    compileSdk = 34
+    compileSdk = 35
 
     defaultConfig {
         applicationId = "com.syncflow"
         minSdk = 26
         targetSdk = 35
         versionCode = versionProps["VERSION_CODE"].toString().toInt()
-        versionName = versionProps["VERSION_NAME"].toString()
+        // Single source of truth: the human version always tracks the build number, so the
+        // git tag (v1.0.N), the APK filename, and the in-app "About" all read 1.0.N and
+        // can never drift apart again. Bump only VERSION_CODE in version.properties.
+        versionName = "1.0.${versionProps["VERSION_CODE"].toString().toInt()}"
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
 
         // Placeholder — replace with real keys before release
@@ -38,19 +47,28 @@ android {
 
     signingConfigs {
         create("release") {
-            storeFile = localProps["KEYSTORE_PATH"]?.toString()?.let { file(it) }
-            storePassword = localProps["KEYSTORE_PASSWORD"]?.toString()
-            keyAlias = localProps["KEY_ALIAS"]?.toString()
-            keyPassword = localProps["KEY_PASSWORD"]?.toString()
+            if (hasReleaseKeystore) {
+                storeFile = file(keystorePath!!)
+                storePassword = (localProps["KEYSTORE_PASSWORD"] as String?) ?: System.getenv("KEYSTORE_PASSWORD")
+                keyAlias = (localProps["KEY_ALIAS"] as String?) ?: System.getenv("KEY_ALIAS")
+                keyPassword = (localProps["KEY_PASSWORD"] as String?) ?: System.getenv("KEY_PASSWORD")
+            }
         }
     }
 
     buildTypes {
         release {
-            isMinifyEnabled = true
-            isShrinkResources = true
+            // R8/minify has never been exercised by CI (it only built debug), so leave it off
+            // to keep the signed release behaving identically to the debug builds in use today.
+            // Re-enable with proper keep rules and an on-device smoke test if APK size matters.
+            isMinifyEnabled = false
+            isShrinkResources = false
             proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
-            signingConfig = signingConfigs.getByName("release")
+            signingConfig = if (hasReleaseKeystore) {
+                signingConfigs.getByName("release")
+            } else {
+                signingConfigs.getByName("debug")
+            }
         }
     }
 

app/src/androidTest/kotlin/com/syncflow/FullSyncEngineTest.kt

@@ -0,0 +1,465 @@
+package com.syncflow
+
+import androidx.room.Room
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.syncflow.data.db.SyncDatabase
+import com.syncflow.data.db.entities.CloudAccountEntity
+import com.syncflow.data.db.entities.SyncPairEntity
+import com.syncflow.data.db.entities.toDomain
+import com.syncflow.data.providers.CloudProvider
+import com.syncflow.data.providers.nextcloud.NextcloudProvider
+import com.syncflow.domain.sync.LocalAccessor
+import com.syncflow.domain.model.*
+import com.syncflow.domain.sync.SyncEngine
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Assume.assumeTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.time.Instant
+
+/**
+ * Full-matrix end-to-end test of the REAL SyncEngine against a live Nextcloud, on the device:
+ * in-memory Room DB, a real local folder per test, and the real NextcloudProvider over TLS.
+ * Covers every direction, every delete behavior, updates, nested/recursive, filters, and conflicts.
+ *
+ * Creds via instrumentation args: -e ncUrl ... -e ncUser ... -e ncPass ...
+ */
+@RunWith(AndroidJUnit4::class)
+class FullSyncEngineTest {
+
+    private val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    private val args = InstrumentationRegistry.getArguments()
+    private val url get() = args.getString("ncUrl")
+    private val user get() = args.getString("ncUser")
+    private val pass get() = args.getString("ncPass")
+
+    private lateinit var db: SyncDatabase
+    private lateinit var engine: SyncEngine
+    private lateinit var provider: NextcloudProvider
+    private var accountId = 0L
+    private val remoteRoot = "SyncFlowFull_${System.currentTimeMillis()}"
+    private val localDirs = mutableListOf<File>()
+
+    @Before fun setUp() = runBlocking {
+        assumeTrue("ncUrl/ncUser/ncPass required", url != null && user != null && pass != null)
+        db = Room.inMemoryDatabaseBuilder(ctx, SyncDatabase::class.java).build()
+        val account = CloudAccount(0, "IT", user, ProviderType.NEXTCLOUD,
+            """{"username":"$user","password":"$pass"}""", url, null)
+        accountId = db.cloudAccountDao().insert(
+            CloudAccountEntity(0, account.displayName, account.email, account.providerType,
+                account.credentialJson, account.serverUrl, account.port))
+        provider = NextcloudProvider(account)
+        engine = SyncEngine(db.syncPairDao(), db.syncFileStateDao(), db.syncConflictDao(), db.syncEventDao(), ctx)
+        provider.createDirectory(remoteRoot).getOrThrow()
+    }
+
+    @After fun tearDown() = runBlocking {
+        runCatching { provider.deleteFile(remoteRoot) }
+        localDirs.forEach { it.deleteRecursively() }
+        if (::db.isInitialized) db.close()
+    }
+
+    // ── helpers ──────────────────────────────────────────────────────────────
+
+    private suspend fun newPair(
+        name: String,
+        dir: SyncDirection = SyncDirection.TWO_WAY,
+        delete: DeleteBehavior = DeleteBehavior.MIRROR,
+        conflict: ConflictStrategy = ConflictStrategy.KEEP_NEWEST,
+        recursive: Boolean = true,
+        excludeExtensions: String = "",
+        includeExtensions: String = "",
+        excludePatterns: String = "",
+        skipHidden: Boolean = false,
+        minKb: Long = 0L,
+        maxKb: Long = 0L,
+    ): Triple<SyncPair, File, String> {
+        val local = File(ctx.cacheDir, "synctest_${name}_${System.currentTimeMillis()}").apply { mkdirs() }
+        localDirs += local
+        val remote = "$remoteRoot/$name"
+        provider.createDirectory(remote).getOrThrow()
+        val id = db.syncPairDao().insert(SyncPairEntity(
+            id = 0, name = name, localPath = local.absolutePath, remotePath = remote, accountId = accountId,
+            syncDirection = dir, conflictStrategy = conflict, deleteBehavior = delete, recursive = recursive,
+            scheduleType = ScheduleType.MANUAL, scheduleIntervalMinutes = 30, scheduleDailyTime = null, scheduleWeekdays = 0,
+            wifiOnly = false, wifiSsid = "", chargingOnly = false, minBatteryPct = 0,
+            excludePatterns = excludePatterns, includeExtensions = includeExtensions, excludeExtensions = excludeExtensions,
+            skipHiddenFiles = skipHidden, minFileSizeKb = minKb, maxFileSizeKb = maxKb,
+            notifyOnComplete = false, notifyOnError = false,
+            isEnabled = true, lastSyncAt = null, lastSyncResult = SyncStatus.IDLE, pendingConflicts = 0,
+        ))
+        return Triple(db.syncPairDao().getById(id)!!.toDomain(), local, remote)
+    }
+
+    private suspend fun sync(pair: SyncPair) = engine.sync(pair, provider)
+    private fun write(dir: File, rel: String, content: String) =
+        File(dir, rel).apply { parentFile?.mkdirs() }.writeText(content)
+    private suspend fun remoteNames(remote: String) =
+        provider.listFiles(remote).getOrThrow().map { it.name }
+    private suspend fun remoteText(path: String): String {
+        val out = ByteArrayOutputStream(); provider.downloadFile(path, out).getOrThrow(); return out.toString("UTF-8")
+    }
+    private suspend fun putRemote(remote: String, name: String, content: String) {
+        val b = content.toByteArray()
+        provider.uploadFile(ByteArrayInputStream(b), "$remote/$name", b.size.toLong()).getOrThrow()
+    }
+
+    // ── 1. Upload-only backup: delete on phone keeps the cloud copy (KEEP) ────
+    @Test fun uploadOnly_keep_localDeleteKeepsCloud() = runBlocking {
+        val (pair, local, remote) = newPair("ul_keep", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        write(local, "a.txt", "hello")
+        assertEquals(1, sync(pair).uploaded)
+        assertTrue("a.txt" in remoteNames(remote))
+        File(local, "a.txt").delete()
+        val r = sync(pair)
+        assertEquals("KEEP must not delete remotely", 0, r.deleted)
+        assertTrue("cloud copy must survive", "a.txt" in remoteNames(remote))
+    }
+
+    // ── 2. Upload-only + MIRROR: local delete removes the cloud copy ──────────
+    @Test fun uploadOnly_mirror_localDeleteRemovesCloud() = runBlocking {
+        val (pair, local, remote) = newPair("ul_mirror", SyncDirection.UPLOAD_ONLY, DeleteBehavior.MIRROR)
+        write(local, "a.txt", "hello"); assertEquals(1, sync(pair).uploaded)
+        File(local, "a.txt").delete()
+        assertEquals(1, sync(pair).deleted)
+        assertFalse("a.txt" in remoteNames(remote))
+    }
+
+    // ── 3. Upload-only + ARCHIVE: deleted file moved to _Deleted/ ─────────────
+    @Test fun uploadOnly_archive_movesToDeleted() = runBlocking {
+        val (pair, local, remote) = newPair("ul_archive", SyncDirection.UPLOAD_ONLY, DeleteBehavior.ARCHIVE)
+        write(local, "a.txt", "keepme"); sync(pair)
+        File(local, "a.txt").delete(); sync(pair)
+        assertFalse("a.txt" in remoteNames(remote))
+        assertTrue("archived copy expected", "a.txt" in remoteNames("$remote/_Deleted"))
+    }
+
+    // ── 4. Two-way initial sync: each side gets the other's files ─────────────
+    @Test fun twoWay_initial_mergesBothSides() = runBlocking {
+        val (pair, local, remote) = newPair("tw_init", SyncDirection.TWO_WAY)
+        write(local, "local.txt", "L")
+        putRemote(remote, "remote.txt", "R")
+        val r = sync(pair)
+        assertEquals(1, r.uploaded); assertEquals(1, r.downloaded)
+        assertTrue(File(local, "remote.txt").exists())
+        assertTrue("local.txt" in remoteNames(remote) && "remote.txt" in remoteNames(remote))
+    }
+
+    // ── 5. Two-way: a local edit propagates to the remote ─────────────────────
+    @Test fun twoWay_localEdit_updatesRemote() = runBlocking {
+        val (pair, local, remote) = newPair("tw_edit", SyncDirection.TWO_WAY)
+        write(local, "f.txt", "v1"); sync(pair)
+        Thread.sleep(1100) // cross the 1s mtime resolution
+        write(local, "f.txt", "v2-updated"); val r = sync(pair)
+        assertEquals(1, r.uploaded)
+        assertEquals("v2-updated", remoteText("$remote/f.txt"))
+    }
+
+    // ── 6. Two-way + MIRROR: deleting locally removes it remotely ─────────────
+    @Test fun twoWay_mirror_localDeletePropagates() = runBlocking {
+        val (pair, local, remote) = newPair("tw_mirror", SyncDirection.TWO_WAY, DeleteBehavior.MIRROR)
+        write(local, "f.txt", "x"); sync(pair)
+        File(local, "f.txt").delete()
+        assertEquals(1, sync(pair).deleted)
+        assertFalse("f.txt" in remoteNames(remote))
+    }
+
+    // ── 7. Download-only: pulls remote, never uploads local-only files ────────
+    @Test fun downloadOnly_pullsRemoteIgnoresLocal() = runBlocking {
+        val (pair, local, remote) = newPair("dl_only", SyncDirection.DOWNLOAD_ONLY)
+        putRemote(remote, "cloud.txt", "from-cloud")
+        write(local, "phoneonly.txt", "P")
+        val r = sync(pair)
+        assertEquals(1, r.downloaded); assertEquals(0, r.uploaded)
+        assertEquals("from-cloud", File(local, "cloud.txt").readText())
+        assertFalse("local-only file must NOT upload", "phoneonly.txt" in remoteNames(remote))
+    }
+
+    // ── 8. Recursive: nested directory structure is preserved ─────────────────
+    @Test fun recursive_uploadsNestedTree() = runBlocking {
+        val (pair, local, remote) = newPair("rec_on", SyncDirection.UPLOAD_ONLY, recursive = true)
+        write(local, "sub/deep/n.txt", "nested")
+        assertEquals(1, sync(pair).uploaded)
+        assertTrue("n.txt" in remoteNames("$remote/sub/deep"))
+    }
+
+    // ── 9. recursive=false: subfolders are skipped ────────────────────────────
+    @Test fun nonRecursive_skipsSubfolders() = runBlocking {
+        val (pair, local, remote) = newPair("rec_off", SyncDirection.UPLOAD_ONLY, recursive = false)
+        write(local, "top.txt", "T")
+        write(local, "sub/deep.txt", "D")
+        assertEquals(1, sync(pair).uploaded)
+        assertTrue("top.txt" in remoteNames(remote))
+        assertTrue("subfolder must be skipped", remoteNames(remote).none { it == "sub" })
+    }
+
+    // ── 10. Filters: excluded extension + hidden file are not uploaded ─────────
+    @Test fun filters_excludeExtensionAndHidden() = runBlocking {
+        val (pair, local, remote) = newPair("filters", SyncDirection.UPLOAD_ONLY,
+            excludeExtensions = "tmp", skipHidden = true)
+        write(local, "keep.txt", "k")
+        write(local, "skip.tmp", "s")
+        write(local, ".hidden", "h")
+        sync(pair)
+        val names = remoteNames(remote)
+        assertTrue("keep.txt" in names)
+        assertFalse("skip.tmp" in names)
+        assertFalse(".hidden" in names)
+    }
+
+    // ── 11. Conflict: both sides changed (ASK) → conflict recorded, no clobber ─
+    @Test fun twoWay_bothChanged_recordsConflict() = runBlocking {
+        val (pair, local, remote) = newPair("conflict", SyncDirection.TWO_WAY, conflict = ConflictStrategy.ASK)
+        write(local, "c.txt", "base"); sync(pair)                  // upload
+        sync(pair)                                                 // reconcile: record remote baseline (etag/mtime)
+        Thread.sleep(1100)
+        write(local, "c.txt", "LOCAL-change")                       // change local
+        putRemote(remote, "c.txt", "REMOTE-change")                // change remote out-of-band
+        val r = sync(pair)
+        assertEquals("a conflict must be detected", 1, r.conflicts)
+        // ASK must not silently overwrite either side
+        assertEquals("LOCAL-change", File(local, "c.txt").readText())
+        assertEquals("REMOTE-change", remoteText("$remote/c.txt"))
+    }
+
+    // ── 12. Conflict KEEP_NEWEST: newer local wins and uploads ────────────────
+    @Test fun twoWay_keepNewest_newerLocalWins() = runBlocking {
+        val (pair, local, remote) = newPair("newest", SyncDirection.TWO_WAY, conflict = ConflictStrategy.KEEP_NEWEST)
+        write(local, "n.txt", "base"); sync(pair)
+        putRemote(remote, "n.txt", "remote-older")
+        Thread.sleep(1100)
+        write(local, "n.txt", "local-newer")                       // local is newer than remote
+        sync(pair)
+        assertEquals("newer local must win", "local-newer", remoteText("$remote/n.txt"))
+    }
+
+    // ── 13b. Special & non-ASCII filenames upload (WebDAV URL/header encoding) ─
+    @Test fun specialAndNonAsciiNames_upload() = runBlocking {
+        val (pair, local, remote) = newPair("special", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        write(local, "naïve café.txt", "accents")   // non-ASCII (broke MOVE Destination header)
+        write(local, "a&b (1).txt", "ampersand")     // & ( ) space
+        write(local, "日本語.txt", "cjk")              // multibyte unicode
+        write(local, "my photo.txt", "space")
+        val r = sync(pair)
+        assertEquals("all special-name files must upload", 4, r.uploaded)
+        assertEquals(0, r.failedFiles)
+        val names = remoteNames(remote)
+        assertTrue("naïve café.txt" in names)
+        assertTrue("a&b (1).txt" in names)
+        assertTrue("日本語.txt" in names)
+        assertTrue("my photo.txt" in names)
+    }
+
+    // ── 13c. Volume: 100+ files (incl. subfolders & non-ASCII) upload, 0 fails ─
+    @Test fun volume_hundredFiles_allUploadNoFailures() = runBlocking {
+        val (pair, local, remote) = newPair("vol100", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        repeat(100) { i -> write(local, "f_%03d.txt".format(i), "payload $i ".repeat(30)) }
+        write(local, "sub/nested_a.txt", "n1")
+        write(local, "sub/deep/nested_b.txt", "n2")
+        write(local, "naïve café.txt", "accented")
+        val r = sync(pair)
+        assertEquals("no file may fail under volume", 0, r.failedFiles)
+        assertEquals("all 103 files upload", 103, r.uploaded)
+        assertEquals("100 flat files present on cloud", 100, remoteNames(remote).count { it.startsWith("f_") })
+        assertTrue("non-ASCII name present too", "naïve café.txt" in remoteNames(remote))
+        // re-sync is a clean no-op (no phantom re-uploads / loops at volume)
+        val r2 = sync(pair)
+        assertEquals(0, r2.uploaded); assertEquals(0, r2.deleted); assertEquals(0, r2.failedFiles)
+    }
+
+    // ── 14. Content integrity: binary-ish bytes round-trip exactly ────────────
+    @Test fun contentIntegrity_roundTrip() = runBlocking {
+        val (pair, local, remote) = newPair("integrity", SyncDirection.TWO_WAY)
+        val payload = (0..5000).joinToString("") { "Ω$it·" }
+        write(local, "big.txt", payload); sync(pair)
+        assertEquals(payload, remoteText("$remote/big.txt"))
+    }
+
+    // ══ EDGE CASES & STRESS ═══════════════════════════════════════════════════
+
+    private fun writeBytes(dir: File, rel: String, bytes: ByteArray) =
+        File(dir, rel).apply { parentFile?.mkdirs() }.writeBytes(bytes)
+
+    // 15. Empty (0-byte) file uploads correctly
+    @Test fun emptyFile_uploads() = runBlocking {
+        val (pair, local, remote) = newPair("empty", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        write(local, "zero.txt", "")
+        val r = sync(pair)
+        assertEquals(0, r.failedFiles); assertEquals(1, r.uploaded)
+        assertEquals(0L, provider.listFiles(remote).getOrThrow().first { it.name == "zero.txt" }.sizeBytes)
+    }
+
+    // 16. Large file (20 MB) uploads + downloads byte-intact (OOM / streaming guard)
+    @Test fun largeFile_intactRoundTrip() = runBlocking {
+        val (pair, local, remote) = newPair("large", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        val size = 20 * 1024 * 1024
+        val bytes = ByteArray(size).also { java.util.Random(42).nextBytes(it) }
+        writeBytes(local, "big.bin", bytes)
+        val r = sync(pair)
+        assertEquals(0, r.failedFiles); assertEquals(1, r.uploaded)
+        assertEquals(size.toLong(), provider.listFiles(remote).getOrThrow().first { it.name == "big.bin" }.sizeBytes)
+        val out = ByteArrayOutputStream(size); provider.downloadFile("$remote/big.bin", out).getOrThrow()
+        val dl = out.toByteArray()
+        assertEquals(size, dl.size)
+        assertArrayEquals(bytes.copyOfRange(0, 4096), dl.copyOfRange(0, 4096))
+        assertArrayEquals(bytes.copyOfRange(size - 4096, size), dl.copyOfRange(size - 4096, size))
+    }
+
+    // 17. Deeply nested path (8 levels) is created + uploaded
+    @Test fun deepNesting_uploads() = runBlocking {
+        val (pair, local, remote) = newPair("deep", SyncDirection.UPLOAD_ONLY, recursive = true)
+        write(local, "a/b/c/d/e/f/g/deep.txt", "deep")
+        assertEquals(0, sync(pair).failedFiles)
+        assertTrue("deep.txt" in remoteNames("$remote/a/b/c/d/e/f/g"))
+    }
+
+    // 18. Unicode FOLDER names (not just files) are created + encoded
+    @Test fun unicodeFolderNames_upload() = runBlocking {
+        val (pair, local, remote) = newPair("ufolder", SyncDirection.UPLOAD_ONLY, recursive = true)
+        write(local, "Фото/café/x.txt", "u")
+        assertEquals(0, sync(pair).failedFiles)
+        assertTrue("x.txt" in remoteNames("$remote/Фото/café"))
+    }
+
+    // 19. Very long filename (200 chars)
+    @Test fun veryLongFilename_uploads() = runBlocking {
+        val (pair, local, remote) = newPair("longname", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        val name = "L".repeat(200) + ".txt"
+        write(local, name, "x")
+        assertEquals(0, sync(pair).failedFiles)
+        assertTrue(name in remoteNames(remote))
+    }
+
+    // 20. File with no extension
+    @Test fun noExtensionFile_uploads() = runBlocking {
+        val (pair, local, remote) = newPair("noext", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        write(local, "README", "x")
+        assertEquals(1, sync(pair).uploaded)
+        assertTrue("README" in remoteNames(remote))
+    }
+
+    // 21. Idempotency / loop guard — repeated syncs do NOT re-upload anything
+    @Test fun idempotent_repeatedSyncsNoPhantomUploads() = runBlocking {
+        val (pair, local, remote) = newPair("idem", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        repeat(10) { i -> write(local, "x_$i.txt", "v$i") }
+        assertEquals(10, sync(pair).uploaded)
+        repeat(4) {
+            val r = sync(pair)
+            assertEquals("sync must be idempotent (no re-upload loop)", 0, r.uploaded)
+            assertEquals(0, r.deleted); assertEquals(0, r.failedFiles)
+        }
+    }
+
+    // 22. Bulk update — modifying many files re-uploads exactly those
+    @Test fun bulkUpdate_reuploadsChanged() = runBlocking {
+        val (pair, local, remote) = newPair("bulkupd", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        repeat(10) { i -> write(local, "u_$i.txt", "v1") }; sync(pair)
+        Thread.sleep(1100)
+        repeat(10) { i -> write(local, "u_$i.txt", "v2-updated-content") }
+        assertEquals(10, sync(pair).uploaded)
+        assertEquals("v2-updated-content", remoteText("$remote/u_0.txt"))
+    }
+
+    // 23. Bulk delete (MIRROR two-way) propagates all deletions
+    @Test fun mirror_bulkDeletePropagates() = runBlocking {
+        val (pair, local, remote) = newPair("bulkdel", SyncDirection.TWO_WAY, DeleteBehavior.MIRROR)
+        repeat(10) { i -> write(local, "d_$i.txt", "x") }; sync(pair)
+        repeat(10) { i -> File(local, "d_$i.txt").delete() }
+        assertEquals(10, sync(pair).deleted)
+        assertEquals(0, remoteNames(remote).count { it.startsWith("d_") })
+    }
+
+    // 24. Bulk download (download-only) pulls all remote files
+    @Test fun downloadOnly_bulkPull() = runBlocking {
+        val (pair, local, remote) = newPair("bulkdl", SyncDirection.DOWNLOAD_ONLY)
+        repeat(10) { i -> putRemote(remote, "r_$i.txt", "cloud$i") }
+        assertEquals(10, sync(pair).downloaded)
+        assertEquals(10, local.listFiles()!!.count { it.name.startsWith("r_") })
+    }
+
+    // 25. KEEP_BOTH conflict strategy records a conflict (no silent clobber)
+    @Test fun twoWay_keepBoth_recordsConflict() = runBlocking {
+        val (pair, local, remote) = newPair("keepboth", SyncDirection.TWO_WAY, conflict = ConflictStrategy.KEEP_BOTH)
+        write(local, "c.txt", "base"); sync(pair); sync(pair) // baseline + reconcile
+        Thread.sleep(1100)
+        write(local, "c.txt", "LOCAL"); putRemote(remote, "c.txt", "REMOTE")
+        assertEquals(1, sync(pair).conflicts)
+        assertEquals("LOCAL", File(local, "c.txt").readText())
+        assertEquals("REMOTE", remoteText("$remote/c.txt"))
+    }
+
+    // 26. Min-size filter skips tiny files
+    @Test fun filters_minSizeSkipsTiny() = runBlocking {
+        val (pair, local, remote) = newPair("minsize", SyncDirection.UPLOAD_ONLY, minKb = 1)
+        write(local, "tiny.txt", "x")                       // < 1 KB
+        write(local, "big.txt", "A".repeat(2048))           // ~2 KB
+        sync(pair)
+        val n = remoteNames(remote)
+        assertFalse("tiny.txt" in n); assertTrue("big.txt" in n)
+    }
+
+    // 27. Include-extension filter uploads only matching files
+    @Test fun filters_includeExtensionOnly() = runBlocking {
+        val (pair, local, remote) = newPair("incl", SyncDirection.UPLOAD_ONLY, includeExtensions = "jpg")
+        write(local, "keep.jpg", "x"); write(local, "skip.txt", "y")
+        sync(pair)
+        val n = remoteNames(remote)
+        assertTrue("keep.jpg" in n); assertFalse("skip.txt" in n)
+    }
+
+    // 28. Whole-folder wipe locally (MIRROR) removes all remote copies
+    @Test fun mirror_emptyLocalWipesRemote() = runBlocking {
+        val (pair, local, remote) = newPair("wipe", SyncDirection.TWO_WAY, DeleteBehavior.MIRROR)
+        repeat(5) { i -> write(local, "w_$i.txt", "x") }; sync(pair)
+        local.listFiles()!!.forEach { it.delete() }
+        assertEquals(5, sync(pair).deleted)
+        assertEquals(0, remoteNames(remote).count { it.startsWith("w_") })
+    }
+
+    // ══ INTERRUPTION / ATOMICITY ══════════════════════════════════════════════
+
+    // 29. A write that fails mid-stream must leave the existing file intact (no truncation)
+    @Test fun atomicWrite_failedWriteLeavesOriginalIntact() = runBlocking {
+        val dir = File(ctx.cacheDir, "atomic_${System.currentTimeMillis()}").apply { mkdirs() }
+        localDirs += dir
+        File(dir, "f.txt").writeText("ORIGINAL-GOOD-CONTENT")
+        val accessor = LocalAccessor.JavaFile(dir)
+        val outcome = runCatching {
+            accessor.writeAtomically("f.txt") { os ->
+                os.write("PARTIAL-GARBAGE".toByteArray()); os.flush()
+                throw java.io.IOException("simulated network drop mid-download")
+            }
+        }
+        assertTrue("the failed write must propagate", outcome.isFailure)
+        assertEquals("original must be untouched after a failed write", "ORIGINAL-GOOD-CONTENT", File(dir, "f.txt").readText())
+        assertTrue("no leftover .sfpart temp", dir.listFiles()!!.none { it.name.endsWith(".sfpart") })
+    }
+
+    // 30. A sync interrupted partway (provider fails after N files) loses nothing and the
+    //     next sync completes the rest with all content intact.
+    @Test fun interruptedSync_resumesCleanlyNoCorruption() = runBlocking {
+        val (pair, local, remote) = newPair("interrupt", SyncDirection.UPLOAD_ONLY, DeleteBehavior.KEEP)
+        repeat(10) { i -> write(local, "i_$i.txt", "content-$i-".repeat(50)) }
+        // Provider that simulates a connection drop after 4 successful uploads.
+        val flaky = object : CloudProvider by provider {
+            private val n = java.util.concurrent.atomic.AtomicInteger(0)
+            override suspend fun uploadFile(localStream: java.io.InputStream, remotePath: String, sizeBytes: Long, onProgress: (Long) -> Unit): Result<RemoteFile> =
+                if (n.incrementAndGet() > 4) Result.failure(java.io.IOException("connection dropped"))
+                else provider.uploadFile(localStream, remotePath, sizeBytes, onProgress)
+        }
+        val r1 = engine.sync(db.syncPairDao().getById(pair.id)!!.toDomain(), flaky)
+        assertTrue("some files should fail on the dropped sync", r1.failedFiles > 0)
+        // Re-sync with the healthy provider completes the rest.
+        val r2 = engine.sync(db.syncPairDao().getById(pair.id)!!.toDomain(), provider)
+        assertEquals("re-sync must complete with no failures", 0, r2.failedFiles)
+        assertEquals("all 10 files end up on the cloud", 10, remoteNames(remote).count { it.startsWith("i_") })
+        assertEquals("content intact (no truncation)", "content-0-".repeat(50), remoteText("$remote/i_0.txt"))
+    }
+}

app/src/androidTest/kotlin/com/syncflow/NextcloudIntegrationTest.kt

@@ -0,0 +1,185 @@
+package com.syncflow
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.syncflow.data.db.entities.SyncFileStateEntity
+import com.syncflow.data.providers.nextcloud.NextcloudProvider
+import com.syncflow.domain.model.CloudAccount
+import com.syncflow.domain.model.ConflictStrategy
+import com.syncflow.domain.model.DeleteBehavior
+import com.syncflow.domain.model.ProviderType
+import com.syncflow.domain.model.SyncDirection
+import com.syncflow.domain.sync.LocalFileInfo
+import com.syncflow.domain.sync.SyncDecision
+import com.syncflow.domain.sync.syncDecide
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.time.Instant
+
+/**
+ * Real end-to-end test against a live Nextcloud, run ON the device. Exercises the actual
+ * NextcloudProvider (WebDAV over real TLS, including the atomic temp+MOVE upload) and proves
+ * the backup guarantee: with Upload-only + KEEP, "deleted on phone" leaves the cloud copy.
+ *
+ * Credentials are passed as instrumentation args (never committed):
+ *   adb shell am instrument -w \
+ *     -e ncUrl https://nextcloud.khodak.me -e ncUser syncflow-test -e ncPass <pw> \
+ *     com.syncflow.test/androidx.test.runner.AndroidJUnitRunner
+ */
+@RunWith(AndroidJUnit4::class)
+class NextcloudIntegrationTest {
+
+    private val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    private val args = InstrumentationRegistry.getArguments()
+    private val url = args.getString("ncUrl")
+    private val user = args.getString("ncUser")
+    private val pass = args.getString("ncPass")
+
+    private fun provider(): NextcloudProvider {
+        val account = CloudAccount(
+            id = 1L,
+            displayName = "IT",
+            email = user,                       // Nextcloud dav path uses this
+            providerType = ProviderType.NEXTCLOUD,
+            credentialJson = """{"username":"$user","password":"$pass"}""",
+            serverUrl = url,
+            port = null,
+        )
+        return NextcloudProvider(account)
+    }
+
+    @Test
+    fun fullBackupRoundTrip() = runBlocking {
+        assumeTrue("ncUrl/ncUser/ncPass instrumentation args required", url != null && user != null && pass != null)
+        val p = provider()
+        val dir = "SyncFlowITest_${System.currentTimeMillis()}"
+        val remoteFile = "$dir/hello.txt"
+        val content = "SyncFlow integration test — 0 to 100 — ${System.currentTimeMillis()}".toByteArray()
+
+        try {
+            // 1. Connect
+            assertTrue("testConnection failed", p.testConnection().isSuccess)
+
+            // 2. Create the backup folder
+            assertTrue("createDirectory failed", p.createDirectory(dir).isSuccess)
+
+            // 3. Upload (exercises atomic temp-file + MOVE)
+            val uploaded = p.uploadFile(ByteArrayInputStream(content), remoteFile, content.size.toLong())
+            assertTrue("upload failed: ${uploaded.exceptionOrNull()}", uploaded.isSuccess)
+
+            // 4. List — the file is on the cloud with the right size
+            val listed = p.listFiles(dir).getOrThrow()
+            val entry = listed.firstOrNull { it.name == "hello.txt" }
+            assertNotNull("uploaded file not found in listing", entry)
+            assertEquals("remote size mismatch", content.size.toLong(), entry!!.sizeBytes)
+
+            // 5. Download — bytes round-trip intact
+            val out = ByteArrayOutputStream()
+            assertTrue("download failed", p.downloadFile(remoteFile, out).isSuccess)
+            assertEquals("downloaded content mismatch", String(content), out.toString("UTF-8"))
+
+            // 6. THE backup guarantee. Phone copy deleted, state record exists, Upload-only + KEEP.
+            val known = SyncFileStateEntity(
+                syncPairId = 1L, relativePath = "hello.txt",
+                localModifiedAt = Instant.now(), localSizeBytes = content.size.toLong(), localHash = null,
+                remoteModifiedAt = entry.modifiedAt, remoteSizeBytes = entry.sizeBytes, remoteEtag = entry.etag,
+                lastSyncedAt = Instant.now(), syncedHash = null,
+            )
+            val keepDecision = syncDecide(
+                SyncDirection.UPLOAD_ONLY, ConflictStrategy.KEEP_NEWEST, DeleteBehavior.KEEP,
+                local = null, remote = entry, known = known, hasPriorSyncState = true,
+            )
+            assertEquals("KEEP must not delete the cloud copy", SyncDecision.SKIP, keepDecision)
+
+            // ...and the engine would do nothing, so the file is verifiably STILL on the cloud:
+            val stillThere = p.listFiles(dir).getOrThrow().any { it.name == "hello.txt" }
+            assertTrue("cloud copy must survive a local delete under KEEP", stillThere)
+
+            // 7. Contrast: MIRROR would delete it — prove the real DELETE works (also cleanup).
+            val mirrorDecision = syncDecide(
+                SyncDirection.UPLOAD_ONLY, ConflictStrategy.KEEP_NEWEST, DeleteBehavior.MIRROR,
+                local = null, remote = entry, known = known, hasPriorSyncState = true,
+            )
+            assertEquals(SyncDecision.DELETE_REMOTE, mirrorDecision)
+            assertTrue("deleteFile failed", p.deleteFile(remoteFile).isSuccess)
+            val goneAfterDelete = p.listFiles(dir).getOrThrow().none { it.name == "hello.txt" }
+            assertTrue("file should be gone after explicit remote delete", goneAfterDelete)
+        } finally {
+            runCatching { p.deleteFile(dir) } // best-effort cleanup of the test folder
+        }
+    }
+
+    @Test
+    fun chunkedUpload_assemblesLargeFileByteExact() = runBlocking {
+        assumeTrue("ncUrl/ncUser/ncPass required", url != null && user != null && pass != null)
+        // Tiny chunk size exercises multi-chunk assembly without needing a multi-GB file.
+        val account = CloudAccount(
+            id = 1, displayName = "IT", email = user, providerType = ProviderType.NEXTCLOUD,
+            credentialJson = """{"username":"$user","password":"$pass"}""", serverUrl = url, port = null,
+        )
+        val p = NextcloudProvider(account, chunkSize = 1L * 1024 * 1024) // 1 MB chunks
+        val dir = "SyncFlowChunk_${System.currentTimeMillis()}"
+        try {
+            p.createDirectory(dir).getOrThrow()
+            val payload = ByteArray(5 * 1024 * 1024 + 7).also { java.util.Random(7).nextBytes(it) } // ~5 MB -> 6 chunks
+            val up = p.uploadFile(ByteArrayInputStream(payload), "$dir/big.bin", payload.size.toLong())
+            assertTrue("chunked upload failed: ${up.exceptionOrNull()}", up.isSuccess)
+            assertEquals(payload.size.toLong(), p.listFiles(dir).getOrThrow().first { it.name == "big.bin" }.sizeBytes)
+            val out = ByteArrayOutputStream(); p.downloadFile("$dir/big.bin", out).getOrThrow()
+            assertArrayEquals("chunk-assembled content must equal the original bytes", payload, out.toByteArray())
+        } finally {
+            runCatching { p.deleteFile(dir) }
+        }
+    }
+
+    /**
+     * Real-world large-file test: streams a multi-GB file FROM THE PHONE through the app's
+     * chunked-upload path to the external URL, verifies the full size landed, then cleans up.
+     * Opt-in (slow): pass -e bigFileMB=<size>, e.g. 1536 for 1.5 GB.
+     */
+    @Test
+    fun realWorld_largeFileChunkedUpload() = runBlocking {
+        assumeTrue("ncUrl/ncUser/ncPass required", url != null && user != null && pass != null)
+        val mb = args.getString("bigFileMB")?.toIntOrNull() ?: 0
+        assumeTrue("pass -e bigFileMB=<size> to run the big-file test", mb > 0)
+
+        val account = CloudAccount(
+            id = 1, displayName = "IT", email = user, providerType = ProviderType.NEXTCLOUD,
+            credentialJson = """{"username":"$user","password":"$pass"}""", serverUrl = url, port = null,
+        )
+        val p = NextcloudProvider(account) // default 100 MB chunks -> chunked path for >100 MB
+        val dir = "SyncFlowBig_${System.currentTimeMillis()}"
+        val tmp = File(ctx.cacheDir, "bigfile_${System.currentTimeMillis()}.bin")
+        try {
+            val total = mb.toLong() * 1024 * 1024
+            FileOutputStream(tmp).use { os ->
+                val buf = ByteArray(8 * 1024 * 1024)
+                var written = 0L
+                while (written < total) {
+                    val n = minOf(buf.size.toLong(), total - written).toInt()
+                    os.write(buf, 0, n); written += n
+                }
+            }
+            assertEquals(total, tmp.length())
+            p.createDirectory(dir).getOrThrow()
+            val up = p.uploadFile(FileInputStream(tmp), "$dir/big.bin", tmp.length())
+            assertTrue("large chunked upload failed: ${up.exceptionOrNull()}", up.isSuccess)
+            assertEquals("full file size must land on the server", total,
+                p.listFiles(dir).getOrThrow().first { it.name == "big.bin" }.sizeBytes)
+        } finally {
+            tmp.delete()
+            runCatching { p.deleteFile(dir) }
+        }
+    }
+}

app/src/androidTest/kotlin/com/syncflow/SchedulingTest.kt

@@ -0,0 +1,47 @@
+package com.syncflow
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.work.NetworkType
+import com.syncflow.worker.SyncWorker
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.concurrent.TimeUnit
+
+/**
+ * Scheduling/constraint mapping for WorkManager-backed syncs. Verifies the request builders
+ * translate pair settings into the right constraints (Wi-Fi-only, charging-only), interval, input
+ * data, and tags — the deterministic part of scheduling (without waiting for the OS to fire it).
+ */
+@RunWith(AndroidJUnit4::class)
+class SchedulingTest {
+
+    @Test fun periodic_wifiOnly_chargingOnly_intervalAndData() {
+        val req = SyncWorker.buildPeriodicRequest(pairId = 42L, intervalMinutes = 30, wifiOnly = true, chargingOnly = true)
+        val ws = req.workSpec
+        assertEquals(NetworkType.UNMETERED, ws.constraints.requiredNetworkType)
+        assertTrue("charging constraint", ws.constraints.requiresCharging())
+        assertEquals(TimeUnit.MINUTES.toMillis(30), ws.intervalDuration)
+        assertEquals(42L, ws.input.getLong(SyncWorker.KEY_PAIR_ID, -1))
+        assertTrue("sync_42" in req.tags)
+    }
+
+    @Test fun periodic_anyNetwork_noCharging() {
+        val req = SyncWorker.buildPeriodicRequest(pairId = 7L, intervalMinutes = 60, wifiOnly = false, chargingOnly = false)
+        val c = req.workSpec.constraints
+        assertEquals(NetworkType.CONNECTED, c.requiredNetworkType)
+        assertFalse(c.requiresCharging())
+    }
+
+    @Test fun oneTime_constraintsDataAndTag() {
+        val req = SyncWorker.buildOneTimeRequest(pairId = 9L, wifiOnly = true, chargingOnly = false, silent = true)
+        val ws = req.workSpec
+        assertEquals(NetworkType.UNMETERED, ws.constraints.requiredNetworkType)
+        assertFalse(ws.constraints.requiresCharging())
+        assertEquals(9L, ws.input.getLong(SyncWorker.KEY_PAIR_ID, -1))
+        assertTrue(ws.input.getBoolean(SyncWorker.KEY_SILENT, false))
+        assertTrue("sync_9" in req.tags)
+    }
+}

app/src/androidTest/kotlin/com/syncflow/SftpProviderTest.kt

@@ -0,0 +1,69 @@
+package com.syncflow
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.syncflow.data.providers.sftp.SftpProvider
+import com.syncflow.data.security.CredentialStore
+import com.syncflow.domain.model.CloudAccount
+import com.syncflow.domain.model.ProviderType
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+
+/**
+ * Live SFTP test (the other major provider code path: sshj). Runs against a throwaway SFTP
+ * server. Skips unless -e sftpHost/sftpPort/sftpUser/sftpPass are provided.
+ */
+@RunWith(AndroidJUnit4::class)
+class SftpProviderTest {
+
+    private val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    private val args = InstrumentationRegistry.getArguments()
+
+    private fun provider() = SftpProvider(
+        CloudAccount(
+            id = 1, displayName = "sftp", email = null, providerType = ProviderType.SFTP,
+            credentialJson = """{"username":"${args.getString("sftpUser")}","password":"${args.getString("sftpPass")}"}""",
+            serverUrl = args.getString("sftpHost"), port = args.getString("sftpPort")?.toInt(),
+        ),
+        CredentialStore(ctx),
+    )
+
+    @Test fun sftpFullRoundTrip() = runBlocking {
+        assumeTrue("sftp* args required", args.getString("sftpHost") != null)
+        val p = provider()
+        val dir = "upload/it_${System.currentTimeMillis()}"
+
+        // Skip (don't fail) if the endpoint isn't reachable from the test runner's network —
+        // e.g. a phone on an isolated VLAN that only reaches services via the reverse proxy.
+        assumeTrue("SFTP endpoint not reachable from this device's network", p.testConnection().isSuccess)
+        assertTrue("mkdir", p.createDirectory(dir).isSuccess)
+
+        // upload (atomic temp + rename), list, download
+        val body = "sftp round-trip ✓".toByteArray()
+        assertTrue("upload", p.uploadFile(ByteArrayInputStream(body), "$dir/f.txt", body.size.toLong()).isSuccess)
+        assertTrue("f.txt" in p.listFiles(dir).getOrThrow().map { it.name })
+        val out = ByteArrayOutputStream(); p.downloadFile("$dir/f.txt", out).getOrThrow()
+        assertEquals("sftp round-trip ✓", out.toString("UTF-8"))
+
+        // atomic overwrite (temp + rename over existing)
+        val v2 = "updated-content".toByteArray()
+        assertTrue(p.uploadFile(ByteArrayInputStream(v2), "$dir/f.txt", v2.size.toLong()).isSuccess)
+        val out2 = ByteArrayOutputStream(); p.downloadFile("$dir/f.txt", out2).getOrThrow()
+        assertEquals("updated-content", out2.toString("UTF-8"))
+
+        // special / non-ASCII name (SFTP handles UTF-8 natively, no URL encoding)
+        val special = "café & rapport (1).txt"
+        assertTrue(p.uploadFile(ByteArrayInputStream("x".toByteArray()), "$dir/$special", 1).isSuccess)
+        assertTrue(special in p.listFiles(dir).getOrThrow().map { it.name })
+
+        // delete
+        assertTrue(p.deleteFile("$dir/f.txt").isSuccess)
+        assertTrue("f.txt" !in p.listFiles(dir).getOrThrow().map { it.name })
+    }
+}

app/src/androidTest/kotlin/com/syncflow/SftpgoWebDavTest.kt

@@ -0,0 +1,68 @@
+package com.syncflow
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.syncflow.data.providers.webdav.WebDavProvider
+import com.syncflow.domain.model.CloudAccount
+import com.syncflow.domain.model.ProviderType
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+
+/**
+ * Live test of the app's SFTPGo provider (which is WebDavProvider) against a real SFTPGo
+ * server over its externally-exposed WebDAV URL. Validates the provider against a different
+ * WebDAV implementation than Nextcloud. Creds via -e davUrl/davUser/davPass; skips otherwise.
+ */
+@RunWith(AndroidJUnit4::class)
+class SftpgoWebDavTest {
+
+    private val args = InstrumentationRegistry.getArguments()
+
+    private fun provider() = WebDavProvider(
+        CloudAccount(
+            id = 1, displayName = "sftpgo", email = null, providerType = ProviderType.SFTPGO,
+            credentialJson = """{"username":"${args.getString("davUser")}","password":"${args.getString("davPass")}"}""",
+            serverUrl = args.getString("davUrl"), port = null,
+        ),
+    )
+
+    @Test fun sftpgoWebDavRoundTrip() = runBlocking {
+        assumeTrue("davUrl/davUser/davPass required", args.getString("davUrl") != null)
+        val p = provider()
+        val dir = "SyncFlowDav_${System.currentTimeMillis()}"
+        try {
+            assertTrue("testConnection", p.testConnection().isSuccess)
+            assertTrue("mkdir", p.createDirectory(dir).isSuccess)
+
+            // upload (atomic temp + MOVE), list, download — with a non-ASCII payload
+            val body = "sftpgo webdav round-trip ✓ café".toByteArray()
+            assertTrue("upload", p.uploadFile(ByteArrayInputStream(body), "$dir/f.txt", body.size.toLong()).isSuccess)
+            assertTrue("f.txt" in p.listFiles(dir).getOrThrow().map { it.name })
+            val out = ByteArrayOutputStream(); p.downloadFile("$dir/f.txt", out).getOrThrow()
+            assertEquals("sftpgo webdav round-trip ✓ café", out.toString("UTF-8"))
+
+            // overwrite via atomic temp+MOVE
+            val v2 = "updated-content".toByteArray()
+            assertTrue(p.uploadFile(ByteArrayInputStream(v2), "$dir/f.txt", v2.size.toLong()).isSuccess)
+            val out2 = ByteArrayOutputStream(); p.downloadFile("$dir/f.txt", out2).getOrThrow()
+            assertEquals("updated-content", out2.toString("UTF-8"))
+
+            // non-ASCII / special filename (the URL/MOVE-header encoding fix)
+            val special = "café & rapport (1).txt"
+            assertTrue(p.uploadFile(ByteArrayInputStream("x".toByteArray()), "$dir/$special", 1).isSuccess)
+            assertTrue(special in p.listFiles(dir).getOrThrow().map { it.name })
+
+            // delete
+            assertTrue(p.deleteFile("$dir/f.txt").isSuccess)
+            assertTrue("f.txt" !in p.listFiles(dir).getOrThrow().map { it.name })
+        } finally {
+            runCatching { p.deleteFile(dir) }
+        }
+    }
+}

app/src/main/AndroidManifest.xml

@@ -8,6 +8,7 @@
     <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" tools:ignore="ScopedStorage" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_SHORT_SERVICE" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
@@ -65,19 +66,22 @@
             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"
+            android:foregroundServiceType="dataSync|shortService"
+            android:stopWithTask="false"
             android:exported="false" />
 
         <!-- Required on API 29+ so WorkManager can start a typed foreground service -->
         <service
             android:name="androidx.work.impl.foreground.SystemForegroundService"
-            android:foregroundServiceType="dataSync"
+            android:foregroundServiceType="dataSync|shortService"
             tools:node="merge" />
 
         <!-- Remove WorkManager's default initializer — app uses on-demand init via Configuration.Provider -->

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

@@ -1,9 +1,12 @@
 package com.syncflow
 
+import android.Manifest
+import android.content.pm.PackageManager
 import android.os.Build
 import android.os.Bundle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.activity.result.contract.ActivityResultContracts
 import androidx.appcompat.app.AppCompatActivity
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_STRONG
@@ -49,10 +52,14 @@ class MainActivity : AppCompatActivity() {
     private var isLocked by mutableStateOf(false)
     private var showRetry by mutableStateOf(false)
 
+    private val requestNotificationPermission =
+        registerForActivityResult(ActivityResultContracts.RequestPermission()) { /* proceed regardless */ }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         installSplashScreen()
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
+        requestNotificationPermissionIfNeeded()
         setContent {
             SyncFlowTheme {
                 Surface(modifier = Modifier.fillMaxSize()) {
@@ -127,6 +134,16 @@ class MainActivity : AppCompatActivity() {
             BIOMETRIC_WEAK or DEVICE_CREDENTIAL
     }
 
+    private fun requestNotificationPermissionIfNeeded() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS)
+                != PackageManager.PERMISSION_GRANTED
+            ) {
+                requestNotificationPermission.launch(Manifest.permission.POST_NOTIFICATIONS)
+            }
+        }
+    }
+
     private fun canAuthenticate(): Boolean {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R)
             return BiometricManager.from(this).canAuthenticate(BIOMETRIC_STRONG) == BiometricManager.BIOMETRIC_SUCCESS

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

@@ -1,6 +1,9 @@
 package com.syncflow
 
 import android.app.Application
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
 import androidx.hilt.work.HiltWorkerFactory
 import androidx.work.Configuration
 import com.syncflow.data.db.SyncPairDao
@@ -22,6 +25,7 @@ class SyncFlowApp : Application(), Configuration.Provider {
     override fun onCreate() {
         super.onCreate()
         if (BuildConfig.DEBUG) Timber.plant(Timber.DebugTree())
+        createNotificationChannels()
         // Start file watcher on every app launch for any existing ON_CHANGE pairs
         CoroutineScope(Dispatchers.IO).launch {
             val hasOnChange = syncPairDao.getEnabled().any { it.scheduleType == ScheduleType.ON_CHANGE }
@@ -29,6 +33,27 @@ class SyncFlowApp : Application(), Configuration.Provider {
         }
     }
 
+    private fun createNotificationChannels() {
+        val nm = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        listOf(
+            NotificationChannel("sync_progress", "Sync progress", NotificationManager.IMPORTANCE_LOW).apply {
+                description = "Shown while a sync is running"
+            },
+            NotificationChannel("sync_complete", "Sync complete", NotificationManager.IMPORTANCE_LOW).apply {
+                description = "Summary after each successful sync"
+            },
+            NotificationChannel("sync_alerts", "Sync errors", NotificationManager.IMPORTANCE_DEFAULT).apply {
+                description = "Alerts for sync failures and conflicts"
+            },
+            NotificationChannel("sync_watching", "File watching", NotificationManager.IMPORTANCE_MIN).apply {
+                description = "Background service watching folders for changes"
+                setShowBadge(false)
+            },
+        ).forEach { channel ->
+            if (nm.getNotificationChannel(channel.id) == null) nm.createNotificationChannel(channel)
+        }
+    }
+
     override val workManagerConfiguration: Configuration
         get() = Configuration.Builder()
             .setWorkerFactory(workerFactory)

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

@@ -15,20 +15,27 @@ import com.syncflow.data.db.entities.*
         SyncConflictEntity::class,
         SyncEventEntity::class,
     ],
-    version = 3,
+    version = 4,
     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")
             }
         }
+
+        val MIGRATION_3_4 = object : Migration(3, 4) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                db.execSQL("ALTER TABLE sync_pairs ADD COLUMN lastSyncUploaded INTEGER NOT NULL DEFAULT 0")
+                db.execSQL("ALTER TABLE sync_pairs ADD COLUMN lastSyncDownloaded INTEGER NOT NULL DEFAULT 0")
+                db.execSQL("ALTER TABLE sync_pairs ADD COLUMN lastSyncDeleted INTEGER NOT NULL DEFAULT 0")
+                db.execSQL("ALTER TABLE sync_pairs ADD COLUMN lastSyncBytesTransferred INTEGER NOT NULL DEFAULT 0")
+            }
+        }
     }
     abstract fun cloudAccountDao(): CloudAccountDao
     abstract fun syncPairDao(): SyncPairDao

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

@@ -9,6 +9,9 @@ interface SyncEventDao {
     @Query("SELECT * FROM sync_events WHERE syncPairId = :pairId ORDER BY timestamp DESC LIMIT :limit")
     fun observeRecent(pairId: Long, limit: Int = 200): Flow<List<SyncEventEntity>>
 
+    @Query("SELECT * FROM sync_events ORDER BY timestamp DESC LIMIT :limit")
+    fun observeAll(limit: Int = 500): Flow<List<SyncEventEntity>>
+
     @Insert
     suspend fun insert(entity: SyncEventEntity): Long
 

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/db/SyncPairDao.kt

@@ -29,8 +29,8 @@ interface SyncPairDao {
     @Delete
     suspend fun delete(entity: SyncPairEntity)
 
-    @Query("UPDATE sync_pairs SET lastSyncAt = :at, lastSyncResult = :result, pendingConflicts = :conflicts WHERE id = :id")
-    suspend fun updateSyncResult(id: Long, at: Instant, result: SyncStatus, conflicts: Int)
+    @Query("UPDATE sync_pairs SET lastSyncAt = :at, lastSyncResult = :result, pendingConflicts = :conflicts, lastSyncUploaded = :uploaded, lastSyncDownloaded = :downloaded, lastSyncDeleted = :deleted, lastSyncBytesTransferred = :bytes WHERE id = :id")
+    suspend fun updateSyncResult(id: Long, at: Instant, result: SyncStatus, conflicts: Int, uploaded: Int, downloaded: Int, deleted: Int, bytes: Long)
 
     @Query("UPDATE sync_pairs SET lastSyncResult = :status WHERE id = :id")
     suspend fun updateStatus(id: Long, status: SyncStatus)

app/src/main/kotlin/com/syncflow/data/db/entities/SyncPairEntity.kt

@@ -53,6 +53,11 @@ data class SyncPairEntity(
     val lastSyncAt: Instant?,
     val lastSyncResult: SyncStatus,
     val pendingConflicts: Int,
+    // Last sync outcome counters (persist across pause/resume)
+    val lastSyncUploaded: Int = 0,
+    val lastSyncDownloaded: Int = 0,
+    val lastSyncDeleted: Int = 0,
+    val lastSyncBytesTransferred: Long = 0L,
 )
 
 fun SyncPairEntity.toDomain() = SyncPair(

app/src/main/kotlin/com/syncflow/data/providers/ProviderFactory.kt

@@ -7,19 +7,20 @@ import com.syncflow.data.providers.owncloud.OwnCloudProvider
 import com.syncflow.data.providers.onedrive.OneDriveProvider
 import com.syncflow.data.providers.sftp.SftpProvider
 import com.syncflow.data.providers.webdav.WebDavProvider
+import com.syncflow.data.security.CredentialStore
 import com.syncflow.domain.model.CloudAccount
 import com.syncflow.domain.model.ProviderType
 import javax.inject.Inject
 import javax.inject.Singleton
 
 @Singleton
-class ProviderFactory @Inject constructor() {
+class ProviderFactory @Inject constructor(private val credentialStore: CredentialStore) {
     fun create(account: CloudAccount): CloudProvider = when (account.providerType) {
         ProviderType.GOOGLE_DRIVE -> GoogleDriveProvider(account)
         ProviderType.DROPBOX -> DropboxProvider(account)
         ProviderType.ONEDRIVE -> OneDriveProvider(account)
         ProviderType.WEBDAV -> WebDavProvider(account)
-        ProviderType.SFTP -> SftpProvider(account)
+        ProviderType.SFTP -> SftpProvider(account, credentialStore)
         ProviderType.NEXTCLOUD -> NextcloudProvider(account)
         ProviderType.OWNCLOUD -> OwnCloudProvider(account)
         ProviderType.SFTPGO -> WebDavProvider(account)     // SFTPGo exposes WebDAV

app/src/main/kotlin/com/syncflow/data/providers/dropbox/DropboxProvider.kt

@@ -18,9 +18,9 @@ class DropboxProvider(private val account: CloudAccount) : CloudProvider {
     }
     private val client = OkHttpClient()
 
-    private fun apiReq(url: String, bodyJson: String): Request =
+    private fun apiReq(url: String, argJson: JsonObject): Request =
         Request.Builder().url(url)
-            .post(bodyJson.toRequestBody("application/json".toMediaType()))
+            .post(argJson.toString().toRequestBody("application/json".toMediaType()))
             .header("Authorization", "Bearer $token")
             .build()
 
@@ -33,7 +33,8 @@ class DropboxProvider(private val account: CloudAccount) : CloudProvider {
 
     override suspend fun listFiles(remotePath: String): Result<List<RemoteFile>> = runCatching {
         val path = if (remotePath == "/" || remotePath.isBlank()) "" else remotePath
-        val req = apiReq("https://api.dropboxapi.com/2/files/list_folder", """{"path":"$path","recursive":false}""")
+        val arg = buildJsonObject { put("path", path); put("recursive", false) }
+        val req = apiReq("https://api.dropboxapi.com/2/files/list_folder", arg)
         client.newCall(req).execute().use { resp ->
             val body = resp.body?.string() ?: throw Exception("HTTP ${resp.code}")
             if (!resp.isSuccessful) throw Exception("HTTP ${resp.code}: $body")
@@ -44,11 +45,15 @@ class DropboxProvider(private val account: CloudAccount) : CloudProvider {
 
     override suspend fun uploadFile(localStream: InputStream, remotePath: String, sizeBytes: Long, onProgress: (Long) -> Unit): Result<RemoteFile> = runCatching {
         val bytes = localStream.readBytes()
-        val argHeader = """{"path":"${remotePath.normalizeDropbox()}","mode":"overwrite","autorename":false}"""
+        val arg = buildJsonObject {
+            put("path", remotePath.normalizeDropbox())
+            put("mode", "overwrite")
+            put("autorename", false)
+        }
         val req = Request.Builder().url("https://content.dropboxapi.com/2/files/upload")
             .post(bytes.toRequestBody("application/octet-stream".toMediaType()))
             .header("Authorization", "Bearer $token")
-            .header("Dropbox-API-Arg", argHeader).build()
+            .header("Dropbox-API-Arg", arg.toString()).build()
         client.newCall(req).execute().use { resp ->
             val body = resp.body?.string() ?: throw Exception("HTTP ${resp.code}")
             if (!resp.isSuccessful) throw Exception("HTTP ${resp.code}: $body")
@@ -58,11 +63,11 @@ class DropboxProvider(private val account: CloudAccount) : CloudProvider {
     }
 
     override suspend fun downloadFile(remotePath: String, destination: OutputStream, onProgress: (Long) -> Unit): Result<Unit> = runCatching {
-        val argHeader = """{"path":"${remotePath.normalizeDropbox()}"}"""
+        val arg = buildJsonObject { put("path", remotePath.normalizeDropbox()) }
         val req = Request.Builder().url("https://content.dropboxapi.com/2/files/download")
             .post("".toRequestBody())
             .header("Authorization", "Bearer $token")
-            .header("Dropbox-API-Arg", argHeader).build()
+            .header("Dropbox-API-Arg", arg.toString()).build()
         client.newCall(req).execute().use { resp ->
             if (!resp.isSuccessful) throw Exception("HTTP ${resp.code}")
             var total = 0L
@@ -75,17 +80,20 @@ class DropboxProvider(private val account: CloudAccount) : CloudProvider {
     }
 
     override suspend fun deleteFile(remotePath: String): Result<Unit> = runCatching {
-        val req = apiReq("https://api.dropboxapi.com/2/files/delete_v2", """{"path":"${remotePath.normalizeDropbox()}"}""")
+        val arg = buildJsonObject { put("path", remotePath.normalizeDropbox()) }
+        val req = apiReq("https://api.dropboxapi.com/2/files/delete_v2", arg)
         client.newCall(req).execute().use { resp -> if (!resp.isSuccessful) throw Exception("HTTP ${resp.code}") }
     }
 
     override suspend fun createDirectory(remotePath: String): Result<Unit> = runCatching {
-        val req = apiReq("https://api.dropboxapi.com/2/files/create_folder_v2", """{"path":"${remotePath.normalizeDropbox()}"}""")
+        val arg = buildJsonObject { put("path", remotePath.normalizeDropbox()) }
+        val req = apiReq("https://api.dropboxapi.com/2/files/create_folder_v2", arg)
         client.newCall(req).execute().use { resp -> if (!resp.isSuccessful && resp.code != 409) throw Exception("HTTP ${resp.code}") }
     }
 
     override suspend fun getFileMetadata(remotePath: String): Result<RemoteFile> = runCatching {
-        val req = apiReq("https://api.dropboxapi.com/2/files/get_metadata", """{"path":"${remotePath.normalizeDropbox()}"}""")
+        val arg = buildJsonObject { put("path", remotePath.normalizeDropbox()) }
+        val req = apiReq("https://api.dropboxapi.com/2/files/get_metadata", arg)
         client.newCall(req).execute().use { resp ->
             val body = resp.body?.string() ?: throw Exception("HTTP ${resp.code}")
             Json.parseToJsonElement(body).jsonObject.toRemoteFile()
@@ -93,8 +101,11 @@ class DropboxProvider(private val account: CloudAccount) : CloudProvider {
     }
 
     override suspend fun moveFile(fromPath: String, toPath: String): Result<Unit> = runCatching {
-        val req = apiReq("https://api.dropboxapi.com/2/files/move_v2",
-            """{"from_path":"${fromPath.normalizeDropbox()}","to_path":"${toPath.normalizeDropbox()}"}""")
+        val arg = buildJsonObject {
+            put("from_path", fromPath.normalizeDropbox())
+            put("to_path", toPath.normalizeDropbox())
+        }
+        val req = apiReq("https://api.dropboxapi.com/2/files/move_v2", arg)
         client.newCall(req).execute().use { resp -> if (!resp.isSuccessful) throw Exception("HTTP ${resp.code}") }
     }
 

app/src/main/kotlin/com/syncflow/data/providers/google/GoogleDriveProvider.kt

@@ -44,9 +44,11 @@ class GoogleDriveProvider(private val account: CloudAccount) : CloudProvider {
         val name = remotePath.substringAfterLast('/')
         val parentId = if ('/' in remotePath.dropLast(1)) remotePath.substringBeforeLast('/') else "root"
 
-        // Multipart upload
-        val metaPart = """{"name":"$name","parents":["$parentId"]}"""
-            .toRequestBody("application/json".toMediaType())
+        // Multipart upload — use JSON builder to avoid injection via filenames with special chars
+        val metaPart = buildJsonObject {
+            put("name", name)
+            put("parents", buildJsonArray { add(parentId) })
+        }.toString().toRequestBody("application/json".toMediaType())
         val dataPart = bytes.toRequestBody("application/octet-stream".toMediaType())
         val multipart = MultipartBody.Builder()
             .setType(MultipartBody.FORM)
@@ -86,8 +88,11 @@ class GoogleDriveProvider(private val account: CloudAccount) : CloudProvider {
     override suspend fun createDirectory(remotePath: String): Result<Unit> = runCatching {
         val name = remotePath.substringAfterLast('/')
         val parentId = if ('/' in remotePath.dropLast(1)) remotePath.substringBeforeLast('/') else "root"
-        val body = """{"name":"$name","mimeType":"application/vnd.google-apps.folder","parents":["$parentId"]}"""
-            .toRequestBody("application/json".toMediaType())
+        val body = buildJsonObject {
+            put("name", name)
+            put("mimeType", "application/vnd.google-apps.folder")
+            put("parents", buildJsonArray { add(parentId) })
+        }.toString().toRequestBody("application/json".toMediaType())
         val req = auth(Request.Builder().url("https://www.googleapis.com/drive/v3/files").post(body)).build()
         client.newCall(req).execute().use { resp -> if (!resp.isSuccessful) throw Exception("HTTP ${resp.code}") }
     }
@@ -102,7 +107,8 @@ class GoogleDriveProvider(private val account: CloudAccount) : CloudProvider {
 
     override suspend fun moveFile(fromPath: String, toPath: String): Result<Unit> = runCatching {
         val newName = toPath.substringAfterLast('/')
-        val body = """{"name":"$newName"}""".toRequestBody("application/json".toMediaType())
+        val body = buildJsonObject { put("name", newName) }.toString()
+            .toRequestBody("application/json".toMediaType())
         val req = auth(Request.Builder().url("https://www.googleapis.com/drive/v3/files/$fromPath").patch(body)).build()
         client.newCall(req).execute().use { resp -> if (!resp.isSuccessful) throw Exception("HTTP ${resp.code}") }
     }

app/src/main/kotlin/com/syncflow/data/providers/nextcloud/NextcloudProvider.kt

@@ -2,13 +2,111 @@ package com.syncflow.data.providers.nextcloud
 
 import com.syncflow.data.providers.webdav.WebDavProvider
 import com.syncflow.domain.model.CloudAccount
+import com.syncflow.domain.model.RemoteFile
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.Request
+import okhttp3.RequestBody
+import okio.BufferedSink
+import java.io.IOException
+import java.io.InputStream
+
+/**
+ * Nextcloud WebDAV provider. Endpoint is /remote.php/dav/files/<username>/.
+ *
+ * Large files are uploaded via Nextcloud's chunked-upload API (/remote.php/dav/uploads/<user>/)
+ * so they bypass per-request size caps (Apache LimitRequestBody, PHP post_max_size, proxy body
+ * limits) that otherwise 413 a single multi-GB PUT. The assembly MOVE is the atomic commit, so
+ * the destination only appears once every chunk is in — no temp-file dance needed for this path.
+ *
+ * @param chunkSize bytes per chunk; files at or below this use the parent's single-PUT path.
+ */
+class NextcloudProvider(
+    account: CloudAccount,
+    private val chunkSize: Long = 100L * 1024 * 1024,
+) : WebDavProvider(account) {
 
-class NextcloudProvider(account: CloudAccount) : WebDavProvider(account) {
-    // Nextcloud WebDAV endpoint is /remote.php/dav/files/<username>/
     override val baseUrl: String
         get() {
             val server = account.serverUrl?.trimEnd('/') ?: ""
             val email = account.email ?: "user"
             return "$server/remote.php/dav/files/$email"
         }
+
+    private val uploadsBase: String
+        get() {
+            val server = account.serverUrl?.trimEnd('/') ?: ""
+            val email = account.email ?: "user"
+            return "$server/remote.php/dav/uploads/$email"
+        }
+
+    override suspend fun uploadFile(
+        localStream: InputStream,
+        remotePath: String,
+        sizeBytes: Long,
+        onProgress: (Long) -> Unit,
+    ): Result<RemoteFile> {
+        if (sizeBytes <= chunkSize) {
+            return super.uploadFile(localStream, remotePath, sizeBytes, onProgress)
+        }
+        return runCatching {
+            withContext(Dispatchers.IO) {
+                val uploadId = "syncflow-${System.currentTimeMillis()}-${(0..999_999).random()}"
+                val dir = "$uploadsBase/$uploadId"
+                mkcol(dir)
+                try {
+                    var index = 1
+                    var sent = 0L
+                    while (sent < sizeBytes) {
+                        val len = minOf(chunkSize, sizeBytes - sent)
+                        putChunk("$dir/%05d".format(index), localStream, len)
+                        sent += len
+                        index++
+                        onProgress(sent)
+                    }
+                    // Assemble: MOVE the virtual .file onto the destination (atomic commit).
+                    val move = Request.Builder().url("$dir/.file")
+                        .method("MOVE", null)
+                        .header("Destination", url(remotePath))
+                        .header("Overwrite", "T")
+                        .header("OC-Total-Length", sizeBytes.toString())
+                        .build()
+                    client.newCall(move).execute().use { resp ->
+                        if (!resp.isSuccessful) throw IOException("Chunk assembly MOVE HTTP ${resp.code}")
+                    }
+                } catch (e: Throwable) {
+                    runCatching { client.newCall(Request.Builder().url(dir).delete().build()).execute().close() }
+                    throw e
+                }
+                getFileMetadata(remotePath).getOrThrow()
+            }
+        }
+    }
+
+    private fun mkcol(url: String) {
+        client.newCall(Request.Builder().url(url).method("MKCOL", null).build()).execute().use {
+            if (!it.isSuccessful && it.code != 405) throw IOException("MKCOL upload session HTTP ${it.code}")
+        }
+    }
+
+    private fun putChunk(url: String, stream: InputStream, len: Long) {
+        val body = object : RequestBody() {
+            override fun contentType() = "application/octet-stream".toMediaType()
+            override fun contentLength() = len
+            override fun writeTo(sink: BufferedSink) {
+                var remaining = len
+                val buf = ByteArray(64 * 1024)
+                while (remaining > 0) {
+                    val n = stream.read(buf, 0, minOf(buf.size.toLong(), remaining).toInt())
+                    if (n < 0) break
+                    sink.write(buf, 0, n)
+                    remaining -= n
+                }
+            }
+        }
+        client.newCall(Request.Builder().url(url).put(body).build()).execute().use {
+            if (!it.isSuccessful) throw IOException("Chunk PUT HTTP ${it.code}")
+        }
+    }
 }

app/src/main/kotlin/com/syncflow/data/providers/sftp/SftpProvider.kt

@@ -1,6 +1,7 @@
 package com.syncflow.data.providers.sftp
 
 import com.syncflow.data.providers.CloudProvider
+import com.syncflow.data.security.CredentialStore
 import com.syncflow.domain.model.CloudAccount
 import com.syncflow.domain.model.RemoteFile
 import kotlinx.serialization.json.Json
@@ -8,13 +9,12 @@ import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 import net.schmizz.sshj.SSHClient
 import net.schmizz.sshj.sftp.SFTPClient
-import net.schmizz.sshj.transport.verification.PromiscuousVerifier
 import net.schmizz.sshj.xfer.InMemorySourceFile
 import java.io.InputStream
 import java.io.OutputStream
 import java.time.Instant
 
-class SftpProvider(private val account: CloudAccount) : CloudProvider {
+class SftpProvider(private val account: CloudAccount, private val credentialStore: CredentialStore) : CloudProvider {
 
     private val creds = Json.parseToJsonElement(account.credentialJson).jsonObject
     private val host = account.serverUrl ?: "localhost"
@@ -23,19 +23,36 @@ class SftpProvider(private val account: CloudAccount) : CloudProvider {
     private val password = creds["password"]?.jsonPrimitive?.content
     private val privateKey = creds["private_key"]?.jsonPrimitive?.content
 
-    private fun <T> withSftp(block: (SFTPClient) -> T): T {
+    // Persistent SSH connection reused across all operations in the provider's lifetime.
+    // Each call to withSftp checks liveness and reconnects if the connection dropped.
+    // This eliminates the per-operation connect/auth/disconnect cycle that caused
+    // 100+ SSH handshakes during a recursive directory listing + file-transfer sync,
+    // leading to connection timeouts on large folder trees (e.g. 69 subdirectories).
+    private var sshClient: SSHClient? = null
+
+    private fun getOrCreateSsh(): SSHClient {
+        val existing = sshClient
+        if (existing != null && existing.isConnected && existing.isAuthenticated) return existing
         val ssh = SSHClient()
-        ssh.addHostKeyVerifier(PromiscuousVerifier()) // TODO: replace with proper key pinning
+        ssh.addHostKeyVerifier(TofuHostKeyVerifier(credentialStore))
         ssh.connect(host, port)
-        try {
-            if (!privateKey.isNullOrBlank()) {
-                ssh.authPublickey(username, ssh.loadKeys(privateKey, null, null))
-            } else {
-                ssh.authPassword(username, password ?: "")
-            }
-            return ssh.newSFTPClient().use(block)
-        } finally {
-            ssh.disconnect()
+        if (!privateKey.isNullOrBlank()) {
+            ssh.authPublickey(username, ssh.loadKeys(privateKey, null, null))
+        } else {
+            ssh.authPassword(username, password ?: "")
+        }
+        sshClient = ssh
+        return ssh
+    }
+
+    private fun <T> withSftp(block: (SFTPClient) -> T): T {
+        return try {
+            getOrCreateSsh().newSFTPClient().use(block)
+        } catch (e: Exception) {
+            // Connection may have gone stale — reset and retry once with a fresh connection.
+            runCatching { sshClient?.disconnect() }
+            sshClient = null
+            getOrCreateSsh().newSFTPClient().use(block)
         }
     }
 
@@ -43,17 +60,21 @@ class SftpProvider(private val account: CloudAccount) : CloudProvider {
 
     override suspend fun listFiles(remotePath: String): Result<List<RemoteFile>> = runCatching {
         withSftp { sftp ->
-            sftp.ls(remotePath).map { entry ->
-                RemoteFile(
-                    path = "$remotePath/${entry.name}".replace("//", "/"),
-                    name = entry.name,
-                    isDirectory = entry.isDirectory,
-                    sizeBytes = entry.attributes.size,
-                    modifiedAt = Instant.ofEpochSecond(entry.attributes.mtime.toLong()),
-                    etag = null,
-                    mimeType = null,
-                )
-            }
+            sftp.ls(remotePath)
+                // Drop "."/".." and any name with a path separator so a hostile server can't
+                // smuggle a traversal segment into a local/remote path.
+                .filter { it.name != "." && it.name != ".." && !it.name.contains('/') && !it.name.contains('\\') }
+                .map { entry ->
+                    RemoteFile(
+                        path = "$remotePath/${entry.name}".replace("//", "/"),
+                        name = entry.name,
+                        isDirectory = entry.isDirectory,
+                        sizeBytes = entry.attributes.size,
+                        modifiedAt = Instant.ofEpochSecond(entry.attributes.mtime.toLong()),
+                        etag = null,
+                        mimeType = null,
+                    )
+                }
         }
     }
 
@@ -63,12 +84,25 @@ class SftpProvider(private val account: CloudAccount) : CloudProvider {
         sizeBytes: Long,
         onProgress: (Long) -> Unit,
     ): Result<RemoteFile> = runCatching {
+        // Upload to a hidden temp sibling, then rename onto the destination so an interrupted
+        // transfer never leaves a truncated file at the real path.
+        val dir = remotePath.substringBeforeLast('/', "")
+        val name = remotePath.substringAfterLast('/')
+        val tmpPath = if (dir.isEmpty()) ".$name.sfpart" else "$dir/.$name.sfpart"
         withSftp { sftp ->
             sftp.put(object : InMemorySourceFile() {
-                override fun getName() = remotePath.substringAfterLast('/')
+                override fun getName() = name
                 override fun getLength() = sizeBytes
                 override fun getInputStream() = localStream
-            }, remotePath)
+            }, tmpPath)
+            // SFTP rename fails if the target exists on servers without the POSIX-rename
+            // extension, so fall back to removing the destination first.
+            try {
+                sftp.rename(tmpPath, remotePath)
+            } catch (e: Exception) {
+                runCatching { sftp.rm(remotePath) }
+                sftp.rename(tmpPath, remotePath)
+            }
         }
         getFileMetadata(remotePath).getOrThrow()
     }

app/src/main/kotlin/com/syncflow/data/providers/sftp/TofuHostKeyVerifier.kt

@@ -0,0 +1,35 @@
+package com.syncflow.data.providers.sftp
+
+import com.syncflow.data.security.CredentialStore
+import net.schmizz.sshj.transport.verification.HostKeyVerifier
+import java.security.MessageDigest
+import java.security.PublicKey
+
+/**
+ * Trust-On-First-Use SSH host key verifier.
+ *
+ * First connection to a host: fingerprint is stored in EncryptedSharedPreferences and accepted.
+ * Subsequent connections: stored fingerprint must match — mismatch aborts (possible MITM).
+ */
+class TofuHostKeyVerifier(private val credentialStore: CredentialStore) : HostKeyVerifier {
+
+    override fun verify(hostname: String, port: Int, key: PublicKey): Boolean {
+        val fingerprint = sha256Fingerprint(key)
+        val stored = credentialStore.getHostFingerprint(hostname, port)
+        return if (stored == null) {
+            credentialStore.saveHostKey(hostname, port, fingerprint)
+            true
+        } else {
+            stored == fingerprint
+        }
+    }
+
+    // Return empty list so sshj uses server preference order for key exchange.
+    // Our verify() will accept or reject whatever algorithm is negotiated.
+    override fun findExistingAlgorithms(hostname: String, port: Int): List<String> = emptyList()
+
+    private fun sha256Fingerprint(key: PublicKey): String {
+        val digest = MessageDigest.getInstance("SHA-256").digest(key.encoded)
+        return digest.joinToString(":") { "%02x".format(it) }
+    }
+}

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
@@ -10,8 +10,11 @@ import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.jsonObject
 import kotlinx.serialization.json.jsonPrimitive
 import okhttp3.*
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
 import okhttp3.MediaType.Companion.toMediaType
 import okhttp3.RequestBody.Companion.toRequestBody
+import okio.BufferedSink
+import okio.source
 import org.xmlpull.v1.XmlPullParser
 import org.xmlpull.v1.XmlPullParserFactory
 import java.io.InputStream
@@ -38,9 +41,14 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
                     .header("Authorization", Credentials.basic(user, pass))
                     .build()
                 val resp = chain.proceed(req)
-                // follow redirect manually for WebDAV methods (OkHttp skips non-GET/HEAD redirects)
+                // Follow redirects for WebDAV methods (OkHttp skips non-GET/HEAD redirects).
+                // Only follow same-host redirects to prevent credential leakage to a different server.
                 if (resp.code in 301..308) {
                     val location = resp.header("Location") ?: return@addInterceptor resp
+                    val redirectHost = location.toHttpUrlOrNull()?.host
+                    if (redirectHost == null || redirectHost != req.url.host) {
+                        return@addInterceptor resp
+                    }
                     resp.close()
                     val redirectReq = req.newBuilder().url(location).build()
                     chain.proceed(redirectReq)
@@ -53,14 +61,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) {
@@ -79,17 +86,37 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
         onProgress: (Long) -> Unit,
     ): Result<RemoteFile> = runCatching {
         withContext(Dispatchers.IO) {
-            val bytes = localStream.readBytes()
-            val body = bytes.toRequestBody("application/octet-stream".toMediaType())
-            val req = Request.Builder().url(url(remotePath)).put(body).build()
+            val body = object : RequestBody() {
+                override fun contentType() = "application/octet-stream".toMediaType()
+                override fun contentLength() = sizeBytes
+                override fun writeTo(sink: BufferedSink) {
+                    localStream.source().use { source -> sink.writeAll(source) }
+                }
+            }
+            // Upload to a hidden temp sibling first, then MOVE it onto the destination. A
+            // failed PUT leaves the real file untouched instead of overwriting it with a
+            // truncated body; the MOVE is a server-side atomic-ish swap.
+            val tmpPath = tempPathFor(remotePath)
+            val req = Request.Builder().url(url(tmpPath)).put(body).build()
             client.newCall(req).execute().use { resp ->
                 if (!resp.isSuccessful) throw Exception("Upload HTTP ${resp.code}")
             }
-            onProgress(bytes.size.toLong())
+            moveFile(tmpPath, remotePath).getOrElse { e ->
+                runCatching { deleteFile(tmpPath) }
+                throw e
+            }
+            onProgress(sizeBytes)
             getFileMetadata(remotePath).getOrThrow()
         }
     }
 
+    private fun tempPathFor(remotePath: String): String {
+        val dir = remotePath.substringBeforeLast('/', "")
+        val name = remotePath.substringAfterLast('/')
+        val tmp = ".$name.sfpart"
+        return if (dir.isEmpty()) tmp else "$dir/$tmp"
+    }
+
     override suspend fun downloadFile(remotePath: String, destination: OutputStream, onProgress: (Long) -> Unit): Result<Unit> = runCatching {
         withContext(Dispatchers.IO) {
             val req = Request.Builder().url(url(remotePath)).get().build()
@@ -154,7 +181,13 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
         }
     }
 
-    protected fun url(path: String) = "$baseUrl/${path.trimStart('/')}"
+    // Build a properly percent-encoded URL. addPathSegments encodes each segment (spaces,
+    // ampersands, and — critically — non-ASCII like "café"), which keeps OkHttp from rejecting
+    // non-ASCII in the WebDAV MOVE "Destination" header and avoids malformed request URLs.
+    protected fun url(path: String): String {
+        val base = baseUrl.toHttpUrlOrNull() ?: return "$baseUrl/${path.trimStart('/')}"
+        return base.newBuilder().addPathSegments(path.trimStart('/')).build().toString()
+    }
 
     private fun parsePropfind(xml: String, parentPath: String, dropFirst: Boolean = true): List<RemoteFile> {
         val results = mutableListOf<RemoteFile>()
@@ -186,9 +219,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

@@ -3,7 +3,7 @@ package com.syncflow.data.security
 import android.content.Context
 import android.content.SharedPreferences
 import androidx.security.crypto.EncryptedSharedPreferences
-import androidx.security.crypto.MasterKey
+import androidx.security.crypto.MasterKeys
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -12,13 +12,12 @@ import javax.inject.Singleton
 class CredentialStore @Inject constructor(@ApplicationContext private val context: Context) {
 
     private val prefs: SharedPreferences by lazy {
-        val masterKey = MasterKey.Builder(context)
-            .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
-            .build()
+        @Suppress("DEPRECATION")
+        val masterKeyAlias = MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC)
         EncryptedSharedPreferences.create(
-            context,
             "syncflow_credentials",
-            masterKey,
+            masterKeyAlias,
+            context,
             EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
             EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM,
         )
@@ -37,7 +36,7 @@ class CredentialStore @Inject constructor(@ApplicationContext private val contex
         prefs.edit().remove(credKey(accountId)).apply()
     }
 
-    // ── PKCE verifiers (OAuth flow) ───────────────────────────────────────────
+    // ── PKCE verifiers and OAuth state (OAuth flow) ───────────────────────────
 
     fun savePkceVerifier(provider: String, verifier: String) {
         prefs.edit().putString(pkceKey(provider), verifier).apply()
@@ -49,8 +48,18 @@ class CredentialStore @Inject constructor(@ApplicationContext private val contex
         prefs.edit().remove(pkceKey(provider)).apply()
     }
 
+    // ── SFTP host key fingerprints (TOFU) ─────────────────────────────────────
+
+    fun saveHostKey(host: String, port: Int, fingerprint: String) {
+        prefs.edit().putString(hostKey(host, port), fingerprint).apply()
+    }
+
+    fun getHostFingerprint(host: String, port: Int): String? =
+        prefs.getString(hostKey(host, port), null)
+
     // ── Key helpers ───────────────────────────────────────────────────────────
 
     private fun credKey(accountId: Long) = "cred_$accountId"
     private fun pkceKey(provider: String) = "pkce_$provider"
+    private fun hostKey(host: String, port: Int) = "sshhost_${host}_$port"
 }

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

@@ -22,7 +22,7 @@ object AppModule {
     fun provideDatabase(@ApplicationContext ctx: Context): SyncDatabase =
         Room.databaseBuilder(ctx, SyncDatabase::class.java, "syncflow.db")
             .fallbackToDestructiveMigrationFrom(1)
-            .addMigrations(SyncDatabase.MIGRATION_2_3)
+            .addMigrations(SyncDatabase.MIGRATION_2_3, SyncDatabase.MIGRATION_3_4)
             .build()
 
     @Provides fun provideCloudAccountDao(db: SyncDatabase): CloudAccountDao = db.cloudAccountDao()

app/src/main/kotlin/com/syncflow/domain/model/SyncPair.kt

@@ -58,6 +58,7 @@ enum class ConflictStrategy(val label: String) {
 enum class DeleteBehavior(val label: String, val description: String) {
     MIRROR("Mirror deletions", "Delete on target when deleted on source"),
     KEEP("Keep deleted files", "Never delete — only add/update"),
+    ARCHIVE("Archive deleted", "Move files deleted from phone to _Deleted/ folder on remote"),
 }
 
 enum class ScheduleType(val label: String) {
@@ -69,5 +70,5 @@ enum class ScheduleType(val label: String) {
 }
 
 enum class SyncStatus {
-    IDLE, SYNCING, SUCCESS, PARTIAL, FAILED, CONFLICT,
+    IDLE, SYNCING, PAUSED, SUCCESS, PARTIAL, FAILED, CONFLICT,
 }

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

@@ -5,6 +5,8 @@ import android.net.Uri
 import android.provider.DocumentsContract
 import com.syncflow.domain.model.SyncPair
 import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
 
@@ -14,10 +16,17 @@ sealed class LocalAccessor {
 
     abstract fun walkFiles(pair: SyncPair): Map<String, LocalFileInfo>
     abstract fun openInputStream(relativePath: String): InputStream?
-    abstract fun createOutputStream(relativePath: String): OutputStream?
     abstract fun delete(relativePath: String): Boolean
     abstract fun lastModifiedMs(relativePath: String): Long
 
+    /**
+     * Write [relativePath] atomically: stream into a temp sibling first, then swap it into
+     * place only after [write] completes without throwing. An interrupted transfer (network
+     * drop, process death) leaves the existing destination untouched instead of truncating it.
+     * On failure the temp is removed and the exception is rethrown.
+     */
+    abstract suspend fun writeAtomically(relativePath: String, write: suspend (OutputStream) -> Unit)
+
     // ── java.io.File backend (regular /storage/... paths) ────────────────────
 
     class JavaFile(private val root: File) : LocalAccessor() {
@@ -48,10 +57,30 @@ sealed class LocalAccessor {
         override fun openInputStream(relativePath: String): InputStream =
             File(root, relativePath).inputStream()
 
-        override fun createOutputStream(relativePath: String): OutputStream {
+        override suspend fun writeAtomically(relativePath: String, write: suspend (OutputStream) -> Unit) {
             val dest = File(root, relativePath)
             dest.parentFile?.mkdirs()
-            return dest.outputStream()
+            val tmp = File(dest.parentFile, ".${dest.name}.sfpart")
+            try {
+                FileOutputStream(tmp).use { os ->
+                    write(os)
+                    os.flush()
+                    os.fd.sync() // durably persist bytes before the rename swaps the file in
+                }
+            } catch (e: Throwable) {
+                tmp.delete()
+                throw e
+            }
+            // Same-directory rename is atomic on POSIX/Android and replaces the destination.
+            if (!tmp.renameTo(dest)) {
+                try {
+                    tmp.copyTo(dest, overwrite = true)
+                } catch (e: Throwable) {
+                    tmp.delete()
+                    throw e
+                }
+                tmp.delete()
+            }
         }
 
         override fun delete(relativePath: String): Boolean = File(root, relativePath).delete()
@@ -131,7 +160,7 @@ sealed class LocalAccessor {
             return resolver.openInputStream(docUri)
         }
 
-        override fun createOutputStream(relativePath: String): OutputStream? {
+        override suspend fun writeAtomically(relativePath: String, write: suspend (OutputStream) -> Unit) {
             val parts = relativePath.replace('\\', '/').split('/')
             var currentId = DocumentsContract.getTreeDocumentId(treeUri)
 
@@ -141,7 +170,7 @@ sealed class LocalAccessor {
                     val parentUri = DocumentsContract.buildDocumentUriUsingTree(treeUri, currentId)
                     val newDir = DocumentsContract.createDocument(
                         resolver, parentUri, DocumentsContract.Document.MIME_TYPE_DIR, parts[i]
-                    ) ?: return null
+                    ) ?: throw IOException("Cannot create directory ${parts[i]} for $relativePath")
                     DocumentsContract.getDocumentId(newDir)
                 }
             }
@@ -149,19 +178,47 @@ sealed class LocalAccessor {
             val fileName = parts.last()
             val childrenUri = DocumentsContract.buildChildDocumentsUriUsingTree(treeUri, currentId)
             val parentUri = DocumentsContract.buildDocumentUriUsingTree(treeUri, currentId)
+            val tmpName = ".$fileName.sfpart"
 
-            // Delete existing to allow overwrite
-            findChildId(childrenUri, fileName)?.let { existingId ->
-                DocumentsContract.deleteDocument(
-                    resolver,
-                    DocumentsContract.buildDocumentUriUsingTree(treeUri, existingId)
-                )
+            // Clear any leftover temp document from a previously interrupted write.
+            findChildId(childrenUri, tmpName)?.let { staleId ->
+                runCatching {
+                    DocumentsContract.deleteDocument(
+                        resolver, DocumentsContract.buildDocumentUriUsingTree(treeUri, staleId)
+                    )
+                }
             }
 
-            val newUri = DocumentsContract.createDocument(
-                resolver, parentUri, "application/octet-stream", fileName
-            ) ?: return null
-            return resolver.openOutputStream(newUri)
+            val tmpUri = DocumentsContract.createDocument(
+                resolver, parentUri, "application/octet-stream", tmpName
+            ) ?: throw IOException("Cannot create temp document for $relativePath")
+
+            try {
+                (resolver.openOutputStream(tmpUri)
+                    ?: throw IOException("Cannot open temp stream for $relativePath")).use { os ->
+                    write(os)
+                    os.flush()
+                }
+            } catch (e: Throwable) {
+                runCatching { DocumentsContract.deleteDocument(resolver, tmpUri) }
+                throw e
+            }
+
+            // Commit: remove the existing destination, then rename the fully-written temp into
+            // place. If interrupted between the two steps the temp still holds the complete data
+            // (recoverable by hand), which is strictly safer than truncating the destination.
+            findChildId(childrenUri, fileName)?.let { existingId ->
+                DocumentsContract.deleteDocument(
+                    resolver, DocumentsContract.buildDocumentUriUsingTree(treeUri, existingId)
+                )
+            }
+            val renamed = DocumentsContract.renameDocument(resolver, tmpUri, fileName)
+            if (renamed == null) {
+                runCatching { DocumentsContract.deleteDocument(resolver, tmpUri) }
+                throw IOException("Cannot finalize $relativePath")
+            }
+            // Drop the stale cache entry so the next read re-resolves the new document id.
+            docIdCache.remove(relativePath)
         }
 
         override fun delete(relativePath: String): Boolean {

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

@@ -24,6 +24,8 @@ import kotlinx.coroutines.sync.withPermit
 import timber.log.Timber
 import java.io.File
 import java.time.Instant
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
 import javax.inject.Inject
 
 class SyncEngine @Inject constructor(
@@ -33,24 +35,28 @@ class SyncEngine @Inject constructor(
     private val eventDao: SyncEventDao,
     @ApplicationContext private val context: Context,
 ) {
-    suspend fun sync(pair: SyncPair, provider: CloudProvider): SyncResult {
+    suspend fun sync(
+        pair: SyncPair,
+        provider: CloudProvider,
+        onProgress: (suspend (uploaded: Int, downloaded: Int, deleted: Int, bytesTransferred: Long) -> Unit)? = null,
+    ): SyncResult {
         syncPairDao.updateStatus(pair.id, SyncStatus.SYNCING)
         logEvent(pair.id, SyncEventType.SYNC_STARTED, null, null, 0)
 
         return try {
-            val result = performSync(pair, provider)
+            val result = performSync(pair, provider, onProgress = onProgress)
             val finalStatus = when {
                 result.failedFiles > 0 && result.conflicts > 0 -> SyncStatus.CONFLICT
                 result.failedFiles > 0 -> SyncStatus.PARTIAL
                 result.conflicts > 0 -> SyncStatus.CONFLICT
                 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)
+            syncPairDao.updateSyncResult(pair.id, Instant.now(), finalStatus, result.conflicts, result.uploaded, result.downloaded, result.deleted, 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}")
-            syncPairDao.updateSyncResult(pair.id, Instant.now(), SyncStatus.FAILED, 0)
+            syncPairDao.updateSyncResult(pair.id, Instant.now(), SyncStatus.FAILED, 0, 0, 0, 0, 0L)
             logEvent(pair.id, SyncEventType.SYNC_FAILED, null, e.message, 0)
             SyncResult(failedFiles = 1, error = e)
         }
@@ -62,16 +68,70 @@ class SyncEngine @Inject constructor(
         else
             LocalAccessor.JavaFile(File(localPath))
 
-    private suspend fun performSync(pair: SyncPair, provider: CloudProvider): SyncResult {
+    /**
+     * Recursively collect every FILE under [basePath] on the remote, descending into each
+     * subdirectory (one Depth:1 PROPFIND per directory). Directories are never returned as
+     * files — only their contents. The provider already drops the parent entry from each
+     * listing, so children-only is returned; the explicit self-path guard prevents any
+     * pathological infinite recursion. This MUST mirror the recursive local walk: otherwise
+     * files in remote subfolders appear absent and a TWO_WAY/MIRROR sync deletes them locally.
+     */
+    private suspend fun listRemoteFilesRecursive(
+        provider: CloudProvider,
+        basePath: String,
+        depth: Int = 0,
+    ): List<RemoteFile> {
+        if (depth > 64) {
+            Timber.w("SyncEngine: remote recursion depth limit hit at $basePath")
+            return emptyList()
+        }
+        val out = mutableListOf<RemoteFile>()
+        for (entry in provider.listFiles(basePath).getOrThrow()) {
+            if (entry.isDirectory) {
+                if (entry.path.trimEnd('/') != basePath.trimEnd('/')) {
+                    out += listRemoteFilesRecursive(provider, entry.path, depth + 1)
+                }
+            } else {
+                out += entry
+            }
+        }
+        return out
+    }
+
+    private suspend fun performSync(
+        pair: SyncPair,
+        provider: CloudProvider,
+        isRetry: Boolean = false,
+        onProgress: (suspend (Int, Int, Int, Long) -> Unit)? = null,
+    ): SyncResult {
         val accessor = makeAccessor(pair.localPath)
-        val knownStates = fileStateDao.getForPair(pair.id).associateBy { it.relativePath }
-        val remoteFiles = provider.listFiles(pair.remotePath).getOrThrow()
+        var knownStates = fileStateDao.getForPair(pair.id).associateBy { it.relativePath }
+        // The local walk is RECURSIVE, so the remote listing must be too. Listing only the top
+        // level (Depth:1) made every file inside a remote subfolder look "missing from remote",
+        // which on a TWO_WAY/MIRROR pair triggered DELETE_LOCAL and wiped those files off the
+        // device (data loss). Walk the remote tree so subfolder files are matched, not deleted.
+        val remoteFiles = listRemoteFilesRecursive(provider, pair.remotePath)
             .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, onProgress = onProgress)
+        }
+
         val allPaths = (localFiles.keys + remoteFiles.keys + knownStates.keys).toSet()
         val hasPriorSyncState = knownStates.isNotEmpty()
-        val semaphore = Semaphore(4)
+        val semaphore = Semaphore(2)  // limit concurrency to be gentle on the server
+        val uploadedAtomic = AtomicInteger(0)
+        val downloadedAtomic = AtomicInteger(0)
+        val deletedAtomic = AtomicInteger(0)
+        val bytesAtomic = AtomicLong(0L)
 
         // Each async block returns its outcome; no shared mutable state across coroutines.
         data class FileOutcome(
@@ -85,6 +145,14 @@ class SyncEngine @Inject constructor(
             allPaths.map { rel ->
                 async {
                     semaphore.withPermit {
+                        // Defense-in-depth against a malicious/compromised remote returning a
+                        // path that escapes the sync root (e.g. "../../evil"). Skip rather than
+                        // write outside pair.localPath / pair.remotePath.
+                        if (isUnsafeSyncPath(rel)) {
+                            Timber.w("SyncEngine: skipping unsafe path for pair ${pair.id}: $rel")
+                            logEvent(pair.id, SyncEventType.FILE_SKIPPED, rel, "unsafe path", 0)
+                            return@withPermit FileOutcome(skipped = 1)
+                        }
                         val local = localFiles[rel]
                         val remote = remoteFiles[rel]
                         val known = knownStates[rel]
@@ -92,11 +160,10 @@ class SyncEngine @Inject constructor(
 
                         when (decision) {
                             SyncDecision.UPLOAD -> {
-                                var uploadedRemoteFile: RemoteFile? = null
                                 val bytes = runCatching {
                                     ensureRemoteDirs(provider, pair.remotePath, rel)
                                     accessor.openInputStream(rel)?.use { stream ->
-                                        uploadedRemoteFile = provider.uploadFile(stream, "${pair.remotePath}/$rel", local!!.sizeBytes) { }.getOrThrow()
+                                        provider.uploadFile(stream, "${pair.remotePath}/$rel", local!!.sizeBytes) { }.getOrThrow()
                                     }
                                     local!!.sizeBytes
                                 }.getOrElse { e ->
@@ -105,13 +172,20 @@ class SyncEngine @Inject constructor(
                                     return@withPermit FileOutcome(failed = 1)
                                 }
                                 logEvent(pair.id, SyncEventType.FILE_UPLOADED, rel, null, bytes)
+                                val up = uploadedAtomic.incrementAndGet()
+                                bytesAtomic.addAndGet(bytes)
+                                onProgress?.invoke(up, downloadedAtomic.get(), deletedAtomic.get(), bytesAtomic.get())
+                                // Don't store remote metadata from upload response — the server (Nextcloud etc.)
+                                // may change mtime/etag during post-upload processing. Leaving remoteModifiedAt
+                                // null forces the SKIP reconciliation on the next sync to fill it in from the
+                                // directory listing, which is the same source all future syncs will use.
                                 FileOutcome(uploaded = 1, bytesTransferred = bytes,
-                                    newState = buildState(pair.id, rel, local!!, remoteAfterTransfer = uploadedRemoteFile))
+                                    newState = buildState(pair.id, rel, local!!, remoteAfterTransfer = null))
                             }
                             SyncDecision.DOWNLOAD -> {
                                 val bytes = runCatching {
-                                    accessor.createOutputStream(rel)?.use { stream ->
-                                        provider.downloadFile("${pair.remotePath}/$rel", stream) { }
+                                    accessor.writeAtomically(rel) { stream ->
+                                        provider.downloadFile("${pair.remotePath}/$rel", stream) { }.getOrThrow()
                                     }
                                     remote!!.sizeBytes
                                 }.getOrElse { e ->
@@ -124,20 +198,45 @@ class SyncEngine @Inject constructor(
                                     .getOrDefault(System.currentTimeMillis()).takeIf { it > 0L }
                                     ?: System.currentTimeMillis()
                                 logEvent(pair.id, SyncEventType.FILE_DOWNLOADED, rel, null, bytes)
+                                val down = downloadedAtomic.incrementAndGet()
+                                bytesAtomic.addAndGet(bytes)
+                                onProgress?.invoke(uploadedAtomic.get(), down, deletedAtomic.get(), bytesAtomic.get())
                                 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)
+                                val deleted = accessor.delete(rel)
+                                if (!deleted) Timber.w("SyncEngine: DELETE_LOCAL failed (silent) for $rel")
                                 fileStateDao.delete(pair.id, rel)
                                 logEvent(pair.id, SyncEventType.FILE_DELETED, rel, "local", 0)
+                                val del = deletedAtomic.incrementAndGet()
+                                onProgress?.invoke(uploadedAtomic.get(), downloadedAtomic.get(), del, bytesAtomic.get())
                                 FileOutcome(deleted = 1)
                             }
                             SyncDecision.DELETE_REMOTE -> {
-                                provider.deleteFile("${pair.remotePath}/$rel")
-                                fileStateDao.delete(pair.id, rel)
-                                logEvent(pair.id, SyncEventType.FILE_DELETED, rel, "remote", 0)
+                                if (pair.deleteBehavior == DeleteBehavior.ARCHIVE) {
+                                    val archivePath = "${pair.remotePath}/_Deleted/$rel"
+                                    runCatching {
+                                        // Create the _Deleted base itself first — ensureRemoteDirs only
+                                        // makes sub-parents of rel, so for a top-level file the MOVE
+                                        // would otherwise fail with a missing-parent error.
+                                        provider.createDirectory("${pair.remotePath}/_Deleted")
+                                        ensureRemoteDirs(provider, "${pair.remotePath}/_Deleted", rel)
+                                        provider.moveFile("${pair.remotePath}/$rel", archivePath).getOrThrow()
+                                    }.onFailure { e -> Timber.e(e, "SyncEngine: ARCHIVE failed for $rel") }
+                                    fileStateDao.delete(pair.id, rel)
+                                    logEvent(pair.id, SyncEventType.FILE_DELETED, rel, "archived", 0)
+                                } else {
+                                    runCatching { provider.deleteFile("${pair.remotePath}/$rel") }
+                                        .onFailure { e -> Timber.e(e, "SyncEngine: DELETE_REMOTE failed for $rel") }
+                                    fileStateDao.delete(pair.id, rel)
+                                    logEvent(pair.id, SyncEventType.FILE_DELETED, rel, "remote", 0)
+                                }
+                                val del = deletedAtomic.incrementAndGet()
+                                onProgress?.invoke(uploadedAtomic.get(), downloadedAtomic.get(), del, bytesAtomic.get())
                                 FileOutcome(deleted = 1)
                             }
                             SyncDecision.CONFLICT -> {
@@ -203,10 +302,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 +338,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
@@ -259,21 +365,15 @@ internal fun syncDecide(
         }
 
         !localExists && remoteExists -> when {
-            known == null -> if (!hasPriorSyncState) {
-                // Initial sync: no history at all — remote files are new, download them.
+            known == null -> {
+                // No state record: could be a new remote file OR a file whose state was lost.
+                // Downloading is always safer than deleting — if the user deleted the local
+                // copy intentionally, the state record will still exist (known != null) and
+                // the else-branch below correctly deletes the remote copy.
                 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
@@ -309,6 +409,19 @@ internal fun syncDecide(
 
 enum class SyncDecision { UPLOAD, DOWNLOAD, DELETE_LOCAL, DELETE_REMOTE, CONFLICT, SKIP }
 
+/**
+ * True if a relative sync path is unsafe to act on — empty, absolute, or containing a ".."
+ * segment that would let a hostile remote escape the sync root via path traversal. Applied to
+ * every path before any file operation as defense-in-depth (WebDAV already filters names at the
+ * parser; SFTP and any future provider are covered here).
+ */
+internal fun isUnsafeSyncPath(rel: String): Boolean {
+    if (rel.isBlank()) return true
+    val normalized = rel.replace('\\', '/')
+    if (normalized.startsWith("/")) return true
+    return normalized.split('/').any { it == ".." }
+}
+
 data class SyncResult(
     val uploaded: Int = 0,
     val downloaded: Int = 0,

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

@@ -1,10 +1,12 @@
 package com.syncflow.ui.addpair
 
 import android.content.Intent
-import android.net.Uri
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.selection.selectable
+import androidx.compose.ui.semantics.Role
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.text.KeyboardOptions
@@ -22,6 +24,7 @@ import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.unit.dp
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.syncflow.domain.model.*
+import com.syncflow.ui.browser.LocalBrowserDialog
 import com.syncflow.ui.browser.RemoteBrowserDialog
 import java.time.DayOfWeek
 
@@ -33,17 +36,29 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
 
     val context = LocalContext.current
     var showRemoteBrowser by remember { mutableStateOf(false) }
+    var showLocalBrowser by remember { mutableStateOf(false) }
 
-    val dirPicker = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocumentTree()) { uri: Uri? ->
-        uri?.let {
+    val safLauncher = rememberLauncherForActivityResult(ActivityResultContracts.OpenDocumentTree()) { uri ->
+        if (uri != null) {
             context.contentResolver.takePersistableUriPermission(
-                it,
+                uri,
                 Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
             )
-            vm.update { copy(localPath = it.toString()) }
+            vm.update { copy(localPath = uri.toString()) }
         }
     }
 
+    if (showLocalBrowser) {
+        LocalBrowserDialog(
+            initialPath = s.localPath.ifBlank { "" },
+            onSelect = { path ->
+                vm.update { copy(localPath = path) }
+                showLocalBrowser = false
+            },
+            onDismiss = { showLocalBrowser = false },
+        )
+    }
+
     if (showRemoteBrowser && s.selectedAccountId != -1L) {
         RemoteBrowserDialog(
             accountId = s.selectedAccountId,
@@ -108,18 +123,17 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
                 Spacer(Modifier.height(4.dp))
 
                 // Local folder
-                OutlinedTextField(
-                    value = uriToDisplay(s.localPath), onValueChange = {},
-                    label = { Text("Local folder") },
-                    leadingIcon = { Icon(Icons.Default.PhoneAndroid, null) },
-                    trailingIcon = {
-                        IconButton(onClick = { dirPicker.launch(null) }) {
-                            Icon(Icons.Default.FolderOpen, "Browse")
-                        }
-                    },
-                    readOnly = true, singleLine = true, modifier = Modifier.fillMaxWidth(),
-                    placeholder = { Text("Tap to choose folder…") },
-                )
+                Box(modifier = Modifier.fillMaxWidth()) {
+                    OutlinedTextField(
+                        value = uriToDisplay(s.localPath), onValueChange = {},
+                        label = { Text("Local folder") },
+                        leadingIcon = { Icon(Icons.Default.PhoneAndroid, null) },
+                        trailingIcon = { Icon(Icons.Default.FolderOpen, null) },
+                        readOnly = true, singleLine = true, modifier = Modifier.fillMaxWidth(),
+                        placeholder = { Text("Tap to choose folder…") },
+                    )
+                    Box(modifier = Modifier.matchParentSize().clickable { showLocalBrowser = true })
+                }
 
                 // Remote folder
                 OutlinedTextField(
@@ -151,7 +165,7 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
                     label = "Direction",
                     options = SyncDirection.entries,
                     selected = s.syncDirection,
-                    onSelect = { vm.update { copy(syncDirection = it) } },
+                    onSelect = { vm.setDirection(it) },
                     itemLabel = { "${it.label}  —  ${it.description}" },
                 )
                 Spacer(Modifier.height(8.dp))
@@ -167,7 +181,7 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
                     label = "Deletion behaviour",
                     options = DeleteBehavior.entries,
                     selected = s.deleteBehavior,
-                    onSelect = { vm.update { copy(deleteBehavior = it) } },
+                    onSelect = { vm.setDeleteBehavior(it) },
                     itemLabel = { "${it.label}  —  ${it.description}" },
                 )
             }
@@ -370,10 +384,17 @@ private fun <T> RadioGroup(
         }
         options.forEach { option ->
             Row(
-                modifier = Modifier.fillMaxWidth(),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .selectable(
+                        selected = option == selected,
+                        role = Role.RadioButton,
+                        onClick = { onSelect(option) },
+                    ),
                 verticalAlignment = Alignment.CenterVertically,
             ) {
-                RadioButton(selected = option == selected, onClick = { onSelect(option) })
+                // onClick = null: the whole row handles selection (bigger tap target + a11y).
+                RadioButton(selected = option == selected, onClick = null)
                 Text(itemLabel(option), style = MaterialTheme.typography.bodyMedium)
             }
         }

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

@@ -5,11 +5,15 @@ 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
 import com.syncflow.domain.model.*
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.WorkManager
 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.*
@@ -27,7 +31,10 @@ data class AddPairUiState(
     // ── Sync type ────────────────────────────────────────────────────────────
     val syncDirection: SyncDirection = SyncDirection.TWO_WAY,
     val conflictStrategy: ConflictStrategy = ConflictStrategy.KEEP_NEWEST,
-    val deleteBehavior: DeleteBehavior = DeleteBehavior.MIRROR,
+    val deleteBehavior: DeleteBehavior = recommendedDeleteBehavior(SyncDirection.TWO_WAY),
+    // True once the user explicitly picks a deletion behaviour, so changing direction stops
+    // auto-overriding their choice.
+    val deleteBehaviorTouched: Boolean = false,
     val recursive: Boolean = true,
     // ── Schedule ─────────────────────────────────────────────────────────────
     val scheduleType: ScheduleType = ScheduleType.INTERVAL,
@@ -55,9 +62,20 @@ data class AddPairUiState(
     val done: Boolean = false,
 )
 
+/**
+ * Safe default deletion behaviour for a given direction. One-way backups must NOT propagate a
+ * local deletion to the cloud (the whole point of a backup), so they default to KEEP; two-way
+ * sync defaults to MIRROR. The user can always override — all three options stay selectable.
+ */
+internal fun recommendedDeleteBehavior(direction: SyncDirection): DeleteBehavior = when (direction) {
+    SyncDirection.UPLOAD_ONLY, SyncDirection.DOWNLOAD_ONLY -> DeleteBehavior.KEEP
+    SyncDirection.TWO_WAY -> DeleteBehavior.MIRROR
+}
+
 @HiltViewModel
 class AddPairViewModel @Inject constructor(
     private val syncPairDao: SyncPairDao,
+    private val fileStateDao: SyncFileStateDao,
     private val accountDao: CloudAccountDao,
     @ApplicationContext private val context: Context,
     savedState: SavedStateHandle,
@@ -91,6 +109,7 @@ class AddPairViewModel @Inject constructor(
                             syncDirection = pair.syncDirection,
                             conflictStrategy = pair.conflictStrategy,
                             deleteBehavior = pair.deleteBehavior,
+                            deleteBehaviorTouched = true, // preserve the saved choice when editing
                             recursive = pair.recursive,
                             scheduleType = pair.scheduleType,
                             intervalMinutes = pair.scheduleIntervalMinutes,
@@ -117,6 +136,18 @@ class AddPairViewModel @Inject constructor(
 
     fun update(transform: AddPairUiState.() -> AddPairUiState) = _state.update(transform)
 
+    /** Changing direction re-applies the safe deletion default unless the user already chose one. */
+    fun setDirection(direction: SyncDirection) = _state.update { s ->
+        s.copy(
+            syncDirection = direction,
+            deleteBehavior = if (s.deleteBehaviorTouched) s.deleteBehavior else recommendedDeleteBehavior(direction),
+        )
+    }
+
+    fun setDeleteBehavior(behavior: DeleteBehavior) = _state.update {
+        it.copy(deleteBehavior = behavior, deleteBehaviorTouched = true)
+    }
+
     fun save() {
         val s = _state.value
         val errors = buildList {
@@ -148,13 +179,53 @@ 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)
+                val pairId = 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)
+                    }
+                    editPairId
+                }
+                entity.copy(id = pairId)
             }
-                .onSuccess {
-                    if (s.scheduleType == ScheduleType.ON_CHANGE) FileWatchService.start(context)
+                .onSuccess { saved ->
+                    applySchedule(saved)
                     _state.update { it.copy(done = true) }
                 }
                 .onFailure { e -> _state.update { it.copy(isSaving = false, error = e.message) } }
         }
     }
+
+    /**
+     * Register the pair's background work the moment it's saved. Previously this only happened on
+     * the enable-toggle or a reboot, so a freshly-created scheduled pair never actually ran in the
+     * background. Mirrors HomeViewModel.toggleEnabled / BootReceiver.
+     */
+    private fun applySchedule(pair: SyncPairEntity) {
+        val wm = WorkManager.getInstance(context)
+        when (pair.scheduleType) {
+            ScheduleType.ON_CHANGE -> {
+                wm.cancelUniqueWork("periodic_${pair.id}")
+                FileWatchService.start(context)
+            }
+            ScheduleType.MANUAL -> wm.cancelUniqueWork("periodic_${pair.id}")
+            else -> {
+                val req = SyncWorker.buildPeriodicRequest(
+                    pair.id,
+                    pair.scheduleIntervalMinutes.toLong().coerceAtLeast(15),
+                    pair.wifiOnly,
+                    pair.chargingOnly,
+                )
+                wm.enqueueUniquePeriodicWork("periodic_${pair.id}", ExistingPeriodicWorkPolicy.UPDATE, req)
+            }
+        }
+    }
 }

app/src/main/kotlin/com/syncflow/ui/auth/AccountSetupScreen.kt

@@ -2,6 +2,7 @@ package com.syncflow.ui.auth
 
 import android.accounts.AccountManager
 import android.app.Activity
+import android.view.WindowManager
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
 import androidx.compose.foundation.Image
@@ -201,6 +202,15 @@ private fun CredentialContent(
 ) {
     val provider = state.providerType ?: return
 
+    // Prevent screenshots and screen recording while credentials are visible
+    val activity = LocalContext.current as? Activity
+    DisposableEffect(Unit) {
+        activity?.window?.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+        onDispose {
+            activity?.window?.clearFlags(WindowManager.LayoutParams.FLAG_SECURE)
+        }
+    }
+
     Column(
         modifier = modifier
             .padding(horizontal = 20.dp)

app/src/main/kotlin/com/syncflow/ui/auth/OAuthHelper.kt

@@ -38,7 +38,9 @@ private fun generateChallenge(verifier: String): String {
 
 fun launchDropboxOAuth(context: Context, credentialStore: CredentialStore, appKey: String) {
     val verifier = generateVerifier()
+    val state = generateVerifier()
     credentialStore.savePkceVerifier("dropbox", verifier)
+    credentialStore.savePkceVerifier("dropbox_state", state)
     val challenge = generateChallenge(verifier)
     val url = "https://www.dropbox.com/oauth2/authorize" +
         "?client_id=$appKey" +
@@ -46,13 +48,16 @@ fun launchDropboxOAuth(context: Context, credentialStore: CredentialStore, appKe
         "&redirect_uri=syncflow%3A%2F%2Foauth%2Fdropbox" +
         "&code_challenge=$challenge" +
         "&code_challenge_method=S256" +
-        "&token_access_type=offline"
+        "&token_access_type=offline" +
+        "&state=$state"
     openCustomTab(context, url)
 }
 
 fun launchOneDriveOAuth(context: Context, credentialStore: CredentialStore, clientId: String) {
     val verifier = generateVerifier()
+    val state = generateVerifier()
     credentialStore.savePkceVerifier("onedrive", verifier)
+    credentialStore.savePkceVerifier("onedrive_state", state)
     val challenge = generateChallenge(verifier)
     val scopes = "Files.ReadWrite+User.Read+offline_access"
     val url = "https://login.microsoftonline.com/common/oauth2/v2.0/authorize" +
@@ -61,7 +66,8 @@ fun launchOneDriveOAuth(context: Context, credentialStore: CredentialStore, clie
         "&redirect_uri=syncflow%3A%2F%2Foauth%2Fonedrive" +
         "&scope=$scopes" +
         "&code_challenge=$challenge" +
-        "&code_challenge_method=S256"
+        "&code_challenge_method=S256" +
+        "&state=$state"
     openCustomTab(context, url)
 }
 

app/src/main/kotlin/com/syncflow/ui/auth/OAuthRedirectActivity.kt

@@ -28,11 +28,22 @@ class OAuthRedirectActivity : ComponentActivity() {
     private fun handleIntent(intent: Intent) {
         val uri = intent.data ?: run { finish(); return }
         val code = uri.getQueryParameter("code") ?: run { finish(); return }
+        val returnedState = uri.getQueryParameter("state") ?: run { finish(); return }
+
         val provider = when {
             uri.host == "oauth" && uri.path?.contains("dropbox") == true -> "dropbox"
             uri.host == "oauth" && uri.path?.contains("onedrive") == true -> "onedrive"
             else -> run { finish(); return }
         }
+
+        // Validate state before doing anything with the code (CSRF protection)
+        val storedState = credentialStore.getPkceVerifier("${provider}_state")
+        if (storedState == null || returnedState != storedState) {
+            finish()
+            return
+        }
+        credentialStore.removePkceVerifier("${provider}_state")
+
         val appKey = getString(com.syncflow.R.string.dropbox_app_key)
         val odClientId = getString(com.syncflow.R.string.onedrive_client_id)
         lifecycleScope.launch {

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

@@ -0,0 +1,391 @@
+package com.syncflow.ui.browser
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+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.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalView
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Dialog
+import androidx.compose.ui.window.DialogProperties
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import android.content.Intent
+import android.net.Uri
+import android.os.Build
+import android.os.Environment
+import android.provider.Settings
+import androidx.compose.ui.platform.LocalContext
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+
+private data class LocalEntry(val file: File, val childCount: Int)
+
+private val STORAGE_ROOT = File("/storage/emulated/0")
+
+private data class Shortcut(val label: String, val icon: ImageVector, val path: String)
+private val SHORTCUTS = listOf(
+    Shortcut("Camera",    Icons.Default.PhotoCamera, "/storage/emulated/0/DCIM/Camera"),
+    Shortcut("Downloads", Icons.Default.Download,    "/storage/emulated/0/Download"),
+    Shortcut("Documents", Icons.Default.Description, "/storage/emulated/0/Documents"),
+    Shortcut("Pictures",  Icons.Default.Image,       "/storage/emulated/0/Pictures"),
+    Shortcut("Music",     Icons.Default.MusicNote,   "/storage/emulated/0/Music"),
+    Shortcut("Videos",    Icons.Default.Videocam,    "/storage/emulated/0/Movies"),
+)
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun LocalBrowserDialog(
+    initialPath: String = STORAGE_ROOT.absolutePath,
+    onSelect: (path: String) -> Unit,
+    onDismiss: () -> Unit,
+) {
+    var currentPath by remember { mutableStateOf(File(initialPath.ifBlank { STORAGE_ROOT.absolutePath }).let { if (it.isDirectory) it else STORAGE_ROOT }) }
+    var pathStack by remember { mutableStateOf(listOf(currentPath)) }
+    var entries by remember { mutableStateOf<List<LocalEntry>>(emptyList()) }
+    var isLoading by remember { mutableStateOf(true) }
+    var searchQuery by remember { mutableStateOf("") }
+    var searchActive by remember { mutableStateOf(false) }
+    val breadcrumbState = rememberLazyListState()
+    val scope = rememberCoroutineScope()
+
+    fun loadDir(dir: File) {
+        isLoading = true
+        entries = emptyList()
+        scope.launch {
+            val result = withContext(Dispatchers.IO) {
+                dir.listFiles()
+                    ?.filter { it.isDirectory && !it.name.startsWith(".") }
+                    ?.sortedBy { it.name.lowercase() }
+                    ?.map { f -> LocalEntry(f, f.listFiles()?.count { it.isDirectory } ?: 0) }
+                    ?: emptyList()
+            }
+            entries = result
+            isLoading = false
+        }
+    }
+
+    fun navigateTo(dir: File) {
+        currentPath = dir
+        pathStack = pathStack + dir
+        searchQuery = ""
+        searchActive = false
+        loadDir(dir)
+    }
+
+    fun navigateUp(): Boolean {
+        if (pathStack.size <= 1) return false
+        val newStack = pathStack.dropLast(1)
+        pathStack = newStack
+        currentPath = newStack.last()
+        searchQuery = ""
+        searchActive = false
+        loadDir(currentPath)
+        return true
+    }
+
+    fun navigateToBreadcrumb(dir: File) {
+        val idx = pathStack.indexOfLast { it.absolutePath == dir.absolutePath }
+        pathStack = if (idx >= 0) pathStack.take(idx + 1) else listOf(dir)
+        currentPath = dir
+        searchQuery = ""
+        searchActive = false
+        loadDir(dir)
+    }
+
+    LaunchedEffect(Unit) { loadDir(currentPath) }
+
+    // Build breadcrumb segments relative to storage root
+    val relParts = currentPath.absolutePath
+        .removePrefix(STORAGE_ROOT.absolutePath)
+        .trimStart('/')
+        .split('/')
+        .filter { it.isNotEmpty() }
+
+    // Auto-scroll breadcrumbs to end
+    LaunchedEffect(currentPath) {
+        scope.launch { breadcrumbState.animateScrollToItem(maxOf(0, relParts.size)) }
+    }
+
+    val filtered = if (searchQuery.isBlank()) entries
+    else entries.filter { it.file.name.contains(searchQuery, ignoreCase = true) }
+
+    val currentFolderName = currentPath.name.ifBlank { "Internal Storage" }
+    val context = LocalContext.current
+    val hasAllFilesAccess = remember {
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.R || Environment.isExternalStorageManager()
+    }
+
+    Dialog(
+        onDismissRequest = onDismiss,
+        properties = DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = false),
+    ) {
+        val view = LocalView.current
+        val density = LocalDensity.current
+        var topInset by remember { mutableStateOf(0.dp) }
+        var bottomInset by remember { mutableStateOf(56.dp) }
+        DisposableEffect(view) {
+            ViewCompat.setOnApplyWindowInsetsListener(view) { _, insets ->
+                val bars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+                with(density) {
+                    topInset = bars.top.toDp()
+                    bottomInset = maxOf(bars.bottom.toDp(), 56.dp)
+                }
+                insets
+            }
+            ViewCompat.requestApplyInsets(view)
+            onDispose { ViewCompat.setOnApplyWindowInsetsListener(view, null) }
+        }
+
+        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.surface) {
+            Column(modifier = Modifier.fillMaxSize().padding(top = topInset)) {
+
+                // ── Top bar ──────────────────────────────────────────────────
+                TopAppBar(
+                    navigationIcon = {
+                        IconButton(onClick = { if (!navigateUp()) onDismiss() }) {
+                            Icon(Icons.AutoMirrored.Filled.ArrowBack, null)
+                        }
+                    },
+                    title = {
+                        if (searchActive) {
+                            val focusRequester = remember { FocusRequester() }
+                            LaunchedEffect(Unit) { focusRequester.requestFocus() }
+                            OutlinedTextField(
+                                value = searchQuery,
+                                onValueChange = { searchQuery = it },
+                                modifier = Modifier.fillMaxWidth().focusRequester(focusRequester),
+                                placeholder = { Text("Search folders…") },
+                                singleLine = true,
+                                keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
+                                keyboardActions = KeyboardActions(onSearch = {}),
+                                colors = OutlinedTextFieldDefaults.colors(
+                                    focusedBorderColor = Color.Transparent,
+                                    unfocusedBorderColor = Color.Transparent,
+                                ),
+                            )
+                        } else {
+                            Text("Choose Local Folder", style = MaterialTheme.typography.titleMedium)
+                        }
+                    },
+                    actions = {
+                        IconButton(onClick = { searchActive = !searchActive; if (!searchActive) searchQuery = "" }) {
+                            Icon(if (searchActive) Icons.Default.Close else Icons.Default.Search, "Search")
+                        }
+                    },
+                    colors = TopAppBarDefaults.topAppBarColors(containerColor = MaterialTheme.colorScheme.surface),
+                )
+
+                // ── All-files-access banner ──────────────────────────────────
+                if (!hasAllFilesAccess) {
+                    Surface(color = MaterialTheme.colorScheme.errorContainer) {
+                        Row(
+                            modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                            horizontalArrangement = Arrangement.spacedBy(8.dp),
+                        ) {
+                            Icon(Icons.Default.Warning, null, Modifier.size(18.dp), tint = MaterialTheme.colorScheme.onErrorContainer)
+                            Text(
+                                "Grant \"All files access\" to browse and sync all folders",
+                                style = MaterialTheme.typography.bodySmall,
+                                color = MaterialTheme.colorScheme.onErrorContainer,
+                                modifier = Modifier.weight(1f),
+                            )
+                            TextButton(
+                                onClick = {
+                                    val intent = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
+                                        Intent(Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION,
+                                            Uri.fromParts("package", context.packageName, null))
+                                    else Intent(Settings.ACTION_MANAGE_ALL_FILES_ACCESS_PERMISSION)
+                                    context.startActivity(intent)
+                                },
+                                contentPadding = PaddingValues(horizontal = 8.dp, vertical = 4.dp),
+                            ) { Text("Grant", style = MaterialTheme.typography.labelSmall) }
+                        }
+                    }
+                }
+
+                // ── Breadcrumbs ──────────────────────────────────────────────
+                Surface(tonalElevation = 1.dp) {
+                    LazyRow(
+                        state = breadcrumbState,
+                        modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 6.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(2.dp),
+                    ) {
+                        item {
+                            BreadcrumbChip(label = "📱 Storage", isLast = relParts.isEmpty(),
+                                onClick = { navigateToBreadcrumb(STORAGE_ROOT) })
+                        }
+                        itemsIndexed(relParts) { idx, part ->
+                            Icon(Icons.Default.ChevronRight, null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                            val partPath = STORAGE_ROOT.absolutePath + "/" + relParts.take(idx + 1).joinToString("/")
+                            BreadcrumbChip(label = part, isLast = idx == relParts.lastIndex,
+                                onClick = { navigateToBreadcrumb(File(partPath)) })
+                        }
+                    }
+                }
+                HorizontalDivider()
+
+                // ── Content ──────────────────────────────────────────────────
+                Box(modifier = Modifier.weight(1f)) {
+                    when {
+                        isLoading -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                            CircularProgressIndicator()
+                        }
+                        else -> LazyColumn(modifier = Modifier.fillMaxSize()) {
+                            if (currentPath.absolutePath == STORAGE_ROOT.absolutePath && searchQuery.isBlank()) {
+                                item {
+                                    Text("Quick access", style = MaterialTheme.typography.labelSmall,
+                                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                        modifier = Modifier.padding(start = 20.dp, top = 14.dp, bottom = 6.dp))
+                                    LazyRow(contentPadding = PaddingValues(horizontal = 16.dp),
+                                        horizontalArrangement = Arrangement.spacedBy(10.dp),
+                                        modifier = Modifier.padding(bottom = 8.dp)) {
+                                        items(SHORTCUTS.filter { File(it.path).isDirectory }) { sc ->
+                                            ShortcutChip(sc, onClick = { navigateTo(File(sc.path)) })
+                                        }
+                                    }
+                                    HorizontalDivider(modifier = Modifier.padding(vertical = 6.dp))
+                                    Text("All folders", style = MaterialTheme.typography.labelSmall,
+                                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                        modifier = Modifier.padding(start = 20.dp, top = 4.dp, bottom = 4.dp))
+                                }
+                            }
+                            if (filtered.isEmpty()) {
+                                item {
+                                    Box(Modifier.fillParentMaxSize(), contentAlignment = Alignment.Center) {
+                                        Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                                            Icon(Icons.Default.FolderOpen, null, Modifier.size(56.dp),
+                                                tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f))
+                                            Spacer(Modifier.height(12.dp))
+                                            Text(if (searchQuery.isBlank()) "No subfolders" else "No results for \"$searchQuery\"",
+                                                style = MaterialTheme.typography.bodyLarge,
+                                                color = MaterialTheme.colorScheme.onSurfaceVariant)
+                                        }
+                                    }
+                                }
+                            } else {
+                                items(filtered, key = { it.file.absolutePath }) { entry ->
+                                    LocalFolderItem(entry = entry, onClick = { navigateTo(entry.file) })
+                                }
+                            }
+                            item { Spacer(Modifier.height(8.dp)) }
+                        }
+                    }
+                }
+
+                // ── Select button ────────────────────────────────────────────
+                Surface(tonalElevation = 4.dp, modifier = Modifier.fillMaxWidth()) {
+                    Column {
+                        Button(
+                            onClick = { onSelect(currentPath.absolutePath) },
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(start = 16.dp, top = 12.dp, end = 16.dp, bottom = 12.dp)
+                                .height(52.dp),
+                            shape = RoundedCornerShape(14.dp),
+                        ) {
+                            Icon(Icons.Default.CheckCircle, null, Modifier.size(20.dp))
+                            Spacer(Modifier.width(8.dp))
+                            Text("Select  \"$currentFolderName\"",
+                                style = MaterialTheme.typography.titleSmall, fontWeight = FontWeight.SemiBold)
+                        }
+                        Spacer(Modifier.height(bottomInset))
+                    }
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun BreadcrumbChip(label: String, isLast: Boolean, onClick: () -> Unit) {
+    if (isLast) {
+        Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.primaryContainer) {
+            Text(label, modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp),
+                style = MaterialTheme.typography.labelMedium, fontWeight = FontWeight.SemiBold,
+                color = MaterialTheme.colorScheme.onPrimaryContainer, maxLines = 1)
+        }
+    } else {
+        TextButton(onClick = onClick, contentPadding = PaddingValues(horizontal = 8.dp, vertical = 2.dp)) {
+            Text(label, style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.primary, maxLines = 1)
+        }
+    }
+}
+
+@Composable
+private fun ShortcutChip(sc: Shortcut, onClick: () -> Unit) {
+    Surface(
+        onClick = onClick,
+        shape = RoundedCornerShape(14.dp),
+        color = MaterialTheme.colorScheme.secondaryContainer,
+        modifier = Modifier.height(72.dp).width(80.dp),
+    ) {
+        Column(
+            modifier = Modifier.fillMaxSize().padding(8.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.Center,
+        ) {
+            Icon(sc.icon, null, Modifier.size(24.dp), tint = MaterialTheme.colorScheme.onSecondaryContainer)
+            Spacer(Modifier.height(4.dp))
+            Text(sc.label, style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSecondaryContainer, maxLines = 1)
+        }
+    }
+}
+
+@Composable
+private fun LocalFolderItem(entry: LocalEntry, onClick: () -> Unit) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clickable(onClick = onClick)
+            .padding(horizontal = 16.dp, vertical = 10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(14.dp),
+    ) {
+        Box(
+            modifier = Modifier
+                .size(46.dp)
+                .clip(RoundedCornerShape(12.dp))
+                .background(Color(0xFF1B5E20).copy(alpha = 0.12f)),
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(Icons.Default.Folder, null, Modifier.size(26.dp), tint = Color(0xFF2E7D32))
+        }
+        Column(modifier = Modifier.weight(1f)) {
+            Text(entry.file.name, style = MaterialTheme.typography.bodyLarge, maxLines = 1, overflow = TextOverflow.Ellipsis, fontWeight = FontWeight.Medium)
+            if (entry.childCount > 0) {
+                Text("${entry.childCount} subfolder${if (entry.childCount == 1) "" else "s"}", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+            }
+        }
+        Icon(Icons.Default.ChevronRight, null, Modifier.size(20.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f))
+    }
+    HorizontalDivider(modifier = Modifier.padding(start = 76.dp), thickness = 0.5.dp)
+}

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

@@ -1,22 +1,40 @@
 package com.syncflow.ui.browser
 
+import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.layout.*
 import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyRow
 import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
 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.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalView
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Dialog
 import androidx.compose.ui.window.DialogProperties
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import androidx.hilt.navigation.compose.hiltViewModel
 import com.syncflow.domain.model.RemoteFile
+import kotlinx.coroutines.launch
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -30,79 +48,205 @@ fun RemoteBrowserDialog(
     LaunchedEffect(accountId, initialPath) { vm.init(accountId, initialPath) }
 
     val state by vm.state.collectAsState()
+    var searchQuery by remember { mutableStateOf("") }
+    var searchActive by remember { mutableStateOf(false) }
+    var showNewFolderDialog by remember { mutableStateOf(false) }
+    val breadcrumbState = rememberLazyListState()
+    val scope = rememberCoroutineScope()
+
+    // Auto-scroll breadcrumbs to end when path changes
+    val segments = state.currentPath.trimEnd('/').split('/').filter { it.isNotEmpty() }
+    LaunchedEffect(state.currentPath) {
+        scope.launch { breadcrumbState.animateScrollToItem(maxOf(0, segments.size)) }
+        searchQuery = ""
+        searchActive = false
+    }
+
+    val filtered = if (searchQuery.isBlank()) state.entries
+    else state.entries.filter { it.name.contains(searchQuery, ignoreCase = true) }
+
+    val currentFolderName = state.currentPath.trimEnd('/').substringAfterLast('/').ifBlank { "Root" }
+
+    if (showNewFolderDialog) {
+        NewFolderDialog(
+            onConfirm = { name ->
+                vm.createFolder(name)
+                showNewFolderDialog = false
+            },
+            onDismiss = { showNewFolderDialog = false },
+        )
+    }
 
     Dialog(
         onDismissRequest = onDismiss,
-        properties = DialogProperties(usePlatformDefaultWidth = false),
+        properties = DialogProperties(usePlatformDefaultWidth = false, decorFitsSystemWindows = false),
     ) {
-        Surface(
-            modifier = Modifier
-                .fillMaxWidth(0.95f)
-                .fillMaxHeight(0.85f),
-            shape = MaterialTheme.shapes.extraLarge,
-            tonalElevation = 6.dp,
-        ) {
-            Column {
-                // Title bar
+        val view = LocalView.current
+        val density = LocalDensity.current
+        var topInset by remember { mutableStateOf(0.dp) }
+        var bottomInset by remember { mutableStateOf(56.dp) }
+        DisposableEffect(view) {
+            ViewCompat.setOnApplyWindowInsetsListener(view) { _, insets ->
+                val bars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+                with(density) {
+                    topInset = bars.top.toDp()
+                    bottomInset = maxOf(bars.bottom.toDp(), 56.dp)
+                }
+                insets
+            }
+            ViewCompat.requestApplyInsets(view)
+            onDispose { ViewCompat.setOnApplyWindowInsetsListener(view, null) }
+        }
+
+        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.surface) {
+            Column(modifier = Modifier.fillMaxSize().padding(top = topInset)) {
+
+                // ── Top bar ──────────────────────────────────────────────────
                 TopAppBar(
-                    title = {
-                        Column {
-                            Text("Choose remote folder", style = MaterialTheme.typography.titleMedium)
-                            Text(
-                                state.currentPath,
-                                style = MaterialTheme.typography.labelSmall,
-                                color = MaterialTheme.colorScheme.onSurfaceVariant,
-                                maxLines = 1,
-                                overflow = TextOverflow.Ellipsis,
-                            )
-                        }
-                    },
                     navigationIcon = {
                         IconButton(onClick = { if (!vm.navigateUp()) onDismiss() }) {
-                            Icon(Icons.Default.ArrowBack, null)
+                            Icon(Icons.AutoMirrored.Filled.ArrowBack, null)
+                        }
+                    },
+                    title = {
+                        if (searchActive) {
+                            val focusRequester = remember { FocusRequester() }
+                            LaunchedEffect(Unit) { focusRequester.requestFocus() }
+                            OutlinedTextField(
+                                value = searchQuery,
+                                onValueChange = { searchQuery = it },
+                                modifier = Modifier.fillMaxWidth().focusRequester(focusRequester),
+                                placeholder = { Text("Search in folder…") },
+                                singleLine = true,
+                                keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
+                                keyboardActions = KeyboardActions(onSearch = {}),
+                                colors = OutlinedTextFieldDefaults.colors(
+                                    focusedBorderColor = Color.Transparent,
+                                    unfocusedBorderColor = Color.Transparent,
+                                ),
+                            )
+                        } else {
+                            Text("Choose Folder", style = MaterialTheme.typography.titleMedium)
                         }
                     },
                     actions = {
-                        // Select current folder
-                        TextButton(onClick = { onSelect(state.currentPath) }) {
-                            Text("Select here")
+                        IconButton(onClick = { searchActive = !searchActive; if (!searchActive) searchQuery = "" }) {
+                            Icon(if (searchActive) Icons.Default.Close else Icons.Default.Search, "Search")
+                        }
+                        IconButton(onClick = { showNewFolderDialog = true }) {
+                            Icon(Icons.Default.CreateNewFolder, "New Folder")
                         }
                     },
-                    colors = TopAppBarDefaults.topAppBarColors(containerColor = MaterialTheme.colorScheme.surfaceContainerHigh),
+                    colors = TopAppBarDefaults.topAppBarColors(containerColor = MaterialTheme.colorScheme.surface),
                 )
 
+                // ── Breadcrumbs ──────────────────────────────────────────────
+                Surface(tonalElevation = 1.dp) {
+                    LazyRow(
+                        state = breadcrumbState,
+                        modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 6.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(2.dp),
+                    ) {
+                        item {
+                            BreadcrumbChip(
+                                label = "⌂",
+                                isLast = segments.isEmpty(),
+                                onClick = { vm.navigateToBreadcrumb("/") },
+                            )
+                        }
+                        itemsIndexed(segments) { idx, seg ->
+                            Icon(Icons.Default.ChevronRight, null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                            val segPath = "/" + segments.take(idx + 1).joinToString("/")
+                            BreadcrumbChip(
+                                label = seg,
+                                isLast = idx == segments.lastIndex,
+                                onClick = { vm.navigateToBreadcrumb(segPath) },
+                            )
+                        }
+                    }
+                }
                 HorizontalDivider()
 
-                when {
-                    state.isLoading -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
-                        CircularProgressIndicator()
-                    }
-                    state.error != null -> Box(Modifier.fillMaxSize().padding(24.dp), contentAlignment = Alignment.Center) {
-                        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") }
+                // ── Content ──────────────────────────────────────────────────
+                Box(modifier = Modifier.weight(1f)) {
+                    when {
+                        state.isLoading -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                            CircularProgressIndicator()
+                        }
+
+                        state.error != null -> Column(
+                            modifier = Modifier.fillMaxSize().padding(32.dp),
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                            verticalArrangement = Arrangement.Center,
+                        ) {
+                            Icon(Icons.Default.CloudOff, null, Modifier.size(56.dp), tint = MaterialTheme.colorScheme.error)
+                            Spacer(Modifier.height(12.dp))
+                            Text(state.error!!, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodyMedium)
+                            Spacer(Modifier.height(16.dp))
+                            FilledTonalButton(onClick = vm::retry) {
+                                Icon(Icons.Default.Refresh, null, Modifier.size(18.dp))
+                                Spacer(Modifier.width(6.dp))
+                                Text("Retry")
+                            }
+                        }
+
+                        filtered.isEmpty() && searchQuery.isBlank() -> Column(
+                            modifier = Modifier.fillMaxSize().padding(32.dp),
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                            verticalArrangement = Arrangement.Center,
+                        ) {
+                            Icon(Icons.Default.FolderOpen, null, Modifier.size(56.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f))
+                            Spacer(Modifier.height(12.dp))
+                            Text("This folder is empty", style = MaterialTheme.typography.bodyLarge, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                            Text("You can still select it", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f))
+                        }
+
+                        filtered.isEmpty() -> Column(
+                            modifier = Modifier.fillMaxSize().padding(32.dp),
+                            horizontalAlignment = Alignment.CenterHorizontally,
+                            verticalArrangement = Arrangement.Center,
+                        ) {
+                            Icon(Icons.Default.SearchOff, null, Modifier.size(56.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f))
+                            Spacer(Modifier.height(12.dp))
+                            Text("No results for \"$searchQuery\"", style = MaterialTheme.typography.bodyLarge, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                        }
+
+                        else -> LazyColumn(modifier = Modifier.fillMaxSize()) {
+                            items(filtered, key = { it.path }) { entry ->
+                                FolderItem(
+                                    file = entry,
+                                    onClick = {
+                                        if (entry.isDirectory) vm.navigateTo(entry.path)
+                                        else onSelect(entry.path.substringBeforeLast('/').ifBlank { "/" })
+                                    },
+                                )
+                            }
+                            item { Spacer(Modifier.height(8.dp)) }
                         }
                     }
-                    state.entries.isEmpty() -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
-                        Column(horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(8.dp)) {
-                            Icon(Icons.Default.FolderOff, null, Modifier.size(48.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
-                            Text("Empty folder", color = MaterialTheme.colorScheme.onSurfaceVariant)
-                            TextButton(onClick = { onSelect(state.currentPath) }) { Text("Select this folder anyway") }
-                        }
-                    }
-                    else -> LazyColumn(modifier = Modifier.fillMaxSize()) {
-                        items(state.entries, key = { it.path }) { entry ->
-                            BrowserEntry(
-                                file = entry,
-                                onClick = {
-                                    if (entry.isDirectory) vm.navigateTo(entry.path)
-                                    else onSelect(entry.path.substringBeforeLast('/').ifBlank { "/" })
-                                },
-                                onSelectFolder = if (entry.isDirectory) ({ onSelect(entry.path) }) else null,
+                }
+
+                // ── Select button ────────────────────────────────────────────
+                Surface(tonalElevation = 4.dp, modifier = Modifier.fillMaxWidth()) {
+                    Column {
+                        Button(
+                            onClick = { onSelect(state.currentPath) },
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(start = 16.dp, top = 12.dp, end = 16.dp, bottom = 12.dp)
+                                .height(52.dp),
+                            shape = RoundedCornerShape(14.dp),
+                        ) {
+                            Icon(Icons.Default.CheckCircle, null, Modifier.size(20.dp))
+                            Spacer(Modifier.width(8.dp))
+                            Text(
+                                "Select  \"$currentFolderName\"",
+                                style = MaterialTheme.typography.titleSmall,
+                                fontWeight = FontWeight.SemiBold,
                             )
-                            HorizontalDivider(modifier = Modifier.padding(start = 56.dp))
                         }
+                        Spacer(Modifier.height(bottomInset))
                     }
                 }
             }
@@ -111,44 +255,119 @@ fun RemoteBrowserDialog(
 }
 
 @Composable
-private fun BrowserEntry(
-    file: RemoteFile,
-    onClick: () -> Unit,
-    onSelectFolder: (() -> Unit)?,
-) {
+private fun BreadcrumbChip(label: String, isLast: Boolean, onClick: () -> Unit) {
+    if (isLast) {
+        Surface(
+            shape = RoundedCornerShape(8.dp),
+            color = MaterialTheme.colorScheme.primaryContainer,
+        ) {
+            Text(
+                label,
+                modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp),
+                style = MaterialTheme.typography.labelMedium,
+                fontWeight = FontWeight.SemiBold,
+                color = MaterialTheme.colorScheme.onPrimaryContainer,
+                maxLines = 1,
+            )
+        }
+    } else {
+        TextButton(
+            onClick = onClick,
+            contentPadding = PaddingValues(horizontal = 8.dp, vertical = 2.dp),
+        ) {
+            Text(
+                label,
+                style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.primary,
+                maxLines = 1,
+            )
+        }
+    }
+}
+
+@Composable
+private fun FolderItem(file: RemoteFile, onClick: () -> Unit) {
     Row(
         modifier = Modifier
             .fillMaxWidth()
             .clickable(onClick = onClick)
             .padding(horizontal = 16.dp, vertical = 10.dp),
         verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(14.dp),
     ) {
-        Icon(
-            imageVector = if (file.isDirectory) Icons.Default.Folder else Icons.Default.InsertDriveFile,
-            contentDescription = null,
-            modifier = Modifier.size(24.dp),
-            tint = if (file.isDirectory) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant,
-        )
-        Spacer(Modifier.width(14.dp))
+        // Colored icon badge
+        Box(
+            modifier = Modifier
+                .size(46.dp)
+                .clip(RoundedCornerShape(12.dp))
+                .background(
+                    if (file.isDirectory) Color(0xFF1B5E20).copy(alpha = 0.12f)
+                    else Color(0xFF0D47A1).copy(alpha = 0.10f)
+                ),
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(
+                imageVector = if (file.isDirectory) Icons.Default.Folder else Icons.Default.InsertDriveFile,
+                contentDescription = null,
+                modifier = Modifier.size(26.dp),
+                tint = if (file.isDirectory) Color(0xFF2E7D32) else Color(0xFF1565C0),
+            )
+        }
+
         Column(modifier = Modifier.weight(1f)) {
-            Text(file.name, style = MaterialTheme.typography.bodyMedium, maxLines = 1, overflow = TextOverflow.Ellipsis)
+            Text(
+                file.name,
+                style = MaterialTheme.typography.bodyLarge,
+                maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                fontWeight = if (file.isDirectory) FontWeight.Medium else FontWeight.Normal,
+            )
             if (!file.isDirectory) {
-                Text(file.sizeBytes.formatBytes(), style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
+                Text(
+                    file.sizeBytes.formatBytes(),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
             }
         }
-        if (onSelectFolder != null) {
-            IconButton(onClick = onSelectFolder, modifier = Modifier.size(36.dp)) {
-                Icon(Icons.Default.CheckCircleOutline, "Select this folder", Modifier.size(20.dp), tint = MaterialTheme.colorScheme.primary)
-            }
-        } else {
-            Icon(Icons.Default.ChevronRight, null, Modifier.size(20.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
+
+        if (file.isDirectory) {
+            Icon(Icons.Default.ChevronRight, null, Modifier.size(20.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f))
         }
     }
+    HorizontalDivider(modifier = Modifier.padding(start = 76.dp), thickness = 0.5.dp)
+}
+
+@Composable
+private fun NewFolderDialog(onConfirm: (String) -> Unit, onDismiss: () -> Unit) {
+    var name by remember { mutableStateOf("") }
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        icon = { Icon(Icons.Default.CreateNewFolder, null) },
+        title = { Text("New Folder") },
+        text = {
+            OutlinedTextField(
+                value = name,
+                onValueChange = { name = it },
+                label = { Text("Folder name") },
+                singleLine = true,
+                modifier = Modifier.fillMaxWidth(),
+                keyboardOptions = KeyboardOptions(imeAction = ImeAction.Done),
+                keyboardActions = KeyboardActions(onDone = { if (name.isNotBlank()) onConfirm(name.trim()) }),
+            )
+        },
+        confirmButton = {
+            TextButton(onClick = { if (name.isNotBlank()) onConfirm(name.trim()) }, enabled = name.isNotBlank()) {
+                Text("Create")
+            }
+        },
+        dismissButton = { TextButton(onClick = onDismiss) { Text("Cancel") } },
+    )
 }
 
 private fun Long.formatBytes(): String = when {
-    this < 1024 -> "${this}B"
-    this < 1_048_576 -> "${"%.1f".format(this / 1024.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"
+    this < 1024 -> "${this} B"
+    this < 1_048_576 -> "${"%.1f".format(this / 1024.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/browser/RemoteBrowserViewModel.kt

@@ -57,6 +57,27 @@ class RemoteBrowserViewModel @Inject constructor(
         return true
     }
 
+    fun navigateToBreadcrumb(path: String) {
+        val stack = _state.value.pathStack
+        val idx = stack.lastIndexOf(path)
+        val newStack = if (idx >= 0) stack.take(idx + 1) else listOf(path)
+        loadJob?.cancel()
+        _state.update { it.copy(currentPath = path, pathStack = newStack, isLoading = true, entries = emptyList(), error = null) }
+        loadJob = loadPath(_state.value.accountId, path)
+    }
+
+    fun createFolder(name: String) {
+        val s = _state.value
+        val newPath = if (s.currentPath.trimEnd('/') == "") "/$name" else "${s.currentPath.trimEnd('/')}/$name"
+        viewModelScope.launch {
+            val account = accountRepository.getAccount(s.accountId) ?: return@launch
+            val provider = runCatching { providerFactory.create(account) }.getOrElse { return@launch }
+            provider.createDirectory(newPath)
+                .onSuccess { retry() }
+                .onFailure { e -> _state.update { it.copy(error = "Could not create folder: ${e.message}") } }
+        }
+    }
+
     fun retry() {
         val s = _state.value
         if (s.accountId == -1L) return

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

@@ -0,0 +1,683 @@
+package com.syncflow.ui.files
+
+import android.content.ClipData
+import android.content.Intent
+import android.webkit.MimeTypeMap
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.*
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyRow
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+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.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.input.ImeAction
+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.ui.browser.RemoteBrowserViewModel
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.File
+
+private val STORAGE_ROOT = File("/storage/emulated/0")
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun FilesScreen(
+    modifier: Modifier = Modifier,
+    vm: FilesViewModel = hiltViewModel(),
+) {
+    var activeTab by remember { mutableStateOf(0) }
+    val context = LocalContext.current
+    val snackbarHostState = remember { SnackbarHostState() }
+    val scope = rememberCoroutineScope()
+    val accounts by vm.accounts.collectAsState()
+    var selectedAccountId by remember { mutableStateOf(-1L) }
+
+    LaunchedEffect(accounts) {
+        if (selectedAccountId == -1L && accounts.isNotEmpty()) selectedAccountId = accounts.first().id
+    }
+
+    val cloudLabel = accounts.find { it.id == selectedAccountId }?.displayName
+        ?: accounts.firstOrNull()?.displayName
+        ?: "Cloud"
+
+    LaunchedEffect(Unit) {
+        vm.fileAction.collect { action ->
+            when (action) {
+                is FileAction.Open -> try {
+                    val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", action.file)
+                    context.startActivity(Intent(Intent.ACTION_VIEW).apply {
+                        setDataAndType(uri, action.file.name.mimeType())
+                        clipData = ClipData.newRawUri("", uri)
+                        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+                    })
+                } catch (e: Exception) {
+                    scope.launch { snackbarHostState.showSnackbar("Cannot open: ${e.message}") }
+                }
+                is FileAction.Share -> try {
+                    val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", action.file)
+                    context.startActivity(
+                        Intent.createChooser(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)
+                        }, "Share").apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) }
+                    )
+                } catch (e: Exception) {
+                    scope.launch { snackbarHostState.showSnackbar("Cannot share: ${e.message}") }
+                }
+                is FileAction.ShareMultiple -> try {
+                    val uris = action.files.map { FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", it) }
+                    context.startActivity(
+                        Intent.createChooser(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)
+                        }, "Share files").apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) }
+                    )
+                } catch (e: Exception) {
+                    scope.launch { snackbarHostState.showSnackbar("Cannot share: ${e.message}") }
+                }
+                is FileAction.Error -> scope.launch { snackbarHostState.showSnackbar(action.message) }
+            }
+        }
+    }
+
+    Box(modifier = modifier.fillMaxSize()) {
+        Column(modifier = Modifier.fillMaxSize()) {
+
+            // ── Phone / Cloud toggle ──────────────────────────────────────────
+            SingleChoiceSegmentedButtonRow(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(horizontal = 16.dp, vertical = 8.dp),
+            ) {
+                SegmentedButton(
+                    selected = activeTab == 0,
+                    onClick = { activeTab = 0 },
+                    shape = SegmentedButtonDefaults.itemShape(0, 2),
+                    icon = { SegmentedButtonDefaults.Icon(active = activeTab == 0, activeContent = { Icon(Icons.Default.PhoneAndroid, null, Modifier.size(16.dp)) }) },
+                ) {
+                    Text("Phone")
+                }
+                SegmentedButton(
+                    selected = activeTab == 1,
+                    onClick = { activeTab = 1 },
+                    shape = SegmentedButtonDefaults.itemShape(1, 2),
+                    icon = { SegmentedButtonDefaults.Icon(active = activeTab == 1, activeContent = { Icon(Icons.Default.Cloud, null, Modifier.size(16.dp)) }) },
+                ) {
+                    Text(cloudLabel, maxLines = 1, overflow = androidx.compose.ui.text.style.TextOverflow.Ellipsis)
+                }
+            }
+            HorizontalDivider()
+
+            when (activeTab) {
+                0 -> LocalExplorer(modifier = Modifier.weight(1f))
+                1 -> CloudExplorer(
+                    vm = vm,
+                    selectedAccountId = selectedAccountId,
+                    onAccountSelect = { selectedAccountId = it },
+                    modifier = Modifier.weight(1f),
+                )
+            }
+        }
+
+        val isDownloading by vm.isDownloading.collectAsState()
+        if (isDownloading) {
+            Surface(
+                color = MaterialTheme.colorScheme.surfaceVariant,
+                tonalElevation = 4.dp,
+                modifier = Modifier.fillMaxWidth().align(Alignment.BottomCenter),
+            ) {
+                Row(
+                    modifier = Modifier.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("Opening file…", style = MaterialTheme.typography.bodySmall)
+                }
+            }
+        }
+
+        SnackbarHost(hostState = snackbarHostState, modifier = Modifier.align(Alignment.BottomCenter))
+    }
+}
+
+// ── Local file explorer ───────────────────────────────────────────────────────
+
+private data class LocalEntry(val file: File, val isDir: Boolean, val childCount: Int = 0, val sizeBytes: Long = 0L)
+
+@Composable
+private fun LocalExplorer(modifier: Modifier = Modifier) {
+    val context = LocalContext.current
+    val scope = rememberCoroutineScope()
+
+    var currentPath by remember { mutableStateOf(STORAGE_ROOT) }
+    var pathStack by remember { mutableStateOf(listOf(STORAGE_ROOT)) }
+    var entries by remember { mutableStateOf<List<LocalEntry>>(emptyList()) }
+    var isLoading by remember { mutableStateOf(true) }
+    var searchQuery by remember { mutableStateOf("") }
+    var searchActive by remember { mutableStateOf(false) }
+    val breadcrumbState = rememberLazyListState()
+    val snackbarHostState = remember { SnackbarHostState() }
+
+    fun loadDir(dir: File) {
+        isLoading = true
+        entries = emptyList()
+        scope.launch {
+            val result = withContext(Dispatchers.IO) {
+                (dir.listFiles() ?: emptyArray())
+                    .filter { !it.name.startsWith(".") }
+                    .sortedWith(compareBy({ !it.isDirectory }, { it.name.lowercase() }))
+                    .map { f ->
+                        if (f.isDirectory) LocalEntry(f, true, f.listFiles()?.size ?: 0)
+                        else LocalEntry(f, false, sizeBytes = f.length())
+                    }
+            }
+            entries = result
+            isLoading = false
+        }
+    }
+
+    fun navigate(dir: File) {
+        currentPath = dir; pathStack = pathStack + dir
+        searchQuery = ""; searchActive = false; loadDir(dir)
+    }
+
+    fun navigateUp(): Boolean {
+        if (pathStack.size <= 1) return false
+        val newStack = pathStack.dropLast(1)
+        pathStack = newStack; currentPath = newStack.last()
+        searchQuery = ""; searchActive = false; loadDir(currentPath)
+        return true
+    }
+
+    LaunchedEffect(Unit) { loadDir(currentPath) }
+    BackHandler(enabled = pathStack.size > 1) { navigateUp() }
+
+    val relParts = currentPath.absolutePath
+        .removePrefix(STORAGE_ROOT.absolutePath).trimStart('/').split('/').filter { it.isNotEmpty() }
+    LaunchedEffect(currentPath) {
+        scope.launch { breadcrumbState.animateScrollToItem(maxOf(0, relParts.size)) }
+        searchQuery = ""; searchActive = false
+    }
+
+    val filtered = if (searchQuery.isBlank()) entries
+    else entries.filter { it.file.name.contains(searchQuery, ignoreCase = true) }
+
+    Box(modifier = modifier) {
+        Column(modifier = Modifier.fillMaxSize()) {
+
+            // ── Breadcrumbs / search bar ──────────────────────────────────────
+            Surface(tonalElevation = 1.dp) {
+                if (searchActive) {
+                    val focusRequester = remember { FocusRequester() }
+                    LaunchedEffect(Unit) { focusRequester.requestFocus() }
+                    Row(
+                        modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        OutlinedTextField(
+                            value = searchQuery, onValueChange = { searchQuery = it },
+                            modifier = Modifier.weight(1f).focusRequester(focusRequester),
+                            placeholder = { Text("Search in folder…") },
+                            singleLine = true,
+                            keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
+                            keyboardActions = KeyboardActions(onSearch = {}),
+                            colors = OutlinedTextFieldDefaults.colors(
+                                focusedBorderColor = Color.Transparent, unfocusedBorderColor = Color.Transparent,
+                            ),
+                        )
+                        IconButton(onClick = { searchActive = false; searchQuery = "" }) {
+                            Icon(Icons.Default.Close, null)
+                        }
+                    }
+                } else {
+                    LazyRow(
+                        state = breadcrumbState,
+                        modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 6.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(2.dp),
+                    ) {
+                        item {
+                            BreadcrumbChip("📱 Storage", relParts.isEmpty()) {
+                                pathStack = listOf(STORAGE_ROOT); currentPath = STORAGE_ROOT; loadDir(STORAGE_ROOT)
+                            }
+                        }
+                        itemsIndexed(relParts) { idx, part ->
+                            Icon(Icons.Default.ChevronRight, null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                            val partFile = File(STORAGE_ROOT, relParts.take(idx + 1).joinToString("/"))
+                            BreadcrumbChip(part, idx == relParts.lastIndex) {
+                                val i = pathStack.indexOfLast { it.absolutePath == partFile.absolutePath }
+                                pathStack = if (i >= 0) pathStack.take(i + 1) else listOf(partFile)
+                                currentPath = partFile; loadDir(partFile)
+                            }
+                        }
+                        item {
+                            Spacer(Modifier.width(4.dp))
+                            IconButton(onClick = { searchActive = true }, modifier = Modifier.size(28.dp)) {
+                                Icon(Icons.Default.Search, null, Modifier.size(18.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                            }
+                        }
+                    }
+                }
+            }
+            HorizontalDivider()
+
+            // ── Content ───────────────────────────────────────────────────────
+            when {
+                isLoading -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                    CircularProgressIndicator()
+                }
+                filtered.isEmpty() -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                        Icon(Icons.Default.FolderOpen, null, Modifier.size(56.dp),
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f))
+                        Spacer(Modifier.height(12.dp))
+                        Text(
+                            if (searchQuery.isBlank()) "Empty folder" else "No results for \"$searchQuery\"",
+                            style = MaterialTheme.typography.bodyLarge,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+                }
+                else -> LazyColumn(modifier = Modifier.fillMaxSize()) {
+                    if (currentPath.absolutePath == STORAGE_ROOT.absolutePath && searchQuery.isBlank()) {
+                        item {
+                            Text("Quick access", style = MaterialTheme.typography.labelSmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                modifier = Modifier.padding(start = 20.dp, top = 14.dp, bottom = 6.dp))
+                            LazyRow(contentPadding = PaddingValues(horizontal = 16.dp),
+                                horizontalArrangement = Arrangement.spacedBy(10.dp),
+                                modifier = Modifier.padding(bottom = 8.dp)) {
+                                val shortcuts = listOf(
+                                    Triple("Camera",    Icons.Default.PhotoCamera,  "/storage/emulated/0/DCIM/Camera"),
+                                    Triple("Downloads", Icons.Default.Download,     "/storage/emulated/0/Download"),
+                                    Triple("Documents", Icons.Default.Description,  "/storage/emulated/0/Documents"),
+                                    Triple("Pictures",  Icons.Default.Image,        "/storage/emulated/0/Pictures"),
+                                    Triple("Music",     Icons.Default.MusicNote,    "/storage/emulated/0/Music"),
+                                    Triple("Videos",    Icons.Default.Videocam,     "/storage/emulated/0/Movies"),
+                                )
+                                items(shortcuts.filter { File(it.third).isDirectory }) { (label, icon, path) ->
+                                    Surface(onClick = { navigate(File(path)) }, shape = RoundedCornerShape(14.dp),
+                                        color = MaterialTheme.colorScheme.secondaryContainer,
+                                        modifier = Modifier.height(72.dp).width(80.dp)) {
+                                        Column(modifier = Modifier.fillMaxSize().padding(8.dp),
+                                            horizontalAlignment = Alignment.CenterHorizontally,
+                                            verticalArrangement = Arrangement.Center) {
+                                            Icon(icon, null, Modifier.size(24.dp), tint = MaterialTheme.colorScheme.onSecondaryContainer)
+                                            Spacer(Modifier.height(4.dp))
+                                            Text(label, style = MaterialTheme.typography.labelSmall,
+                                                color = MaterialTheme.colorScheme.onSecondaryContainer, maxLines = 1)
+                                        }
+                                    }
+                                }
+                            }
+                            HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp))
+                            Text("All files", style = MaterialTheme.typography.labelSmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                                modifier = Modifier.padding(start = 20.dp, top = 4.dp, bottom = 4.dp))
+                        }
+                    }
+                    items(filtered, key = { it.file.absolutePath }) { entry ->
+                        LocalFileItem(
+                            entry = entry,
+                            onClick = {
+                                if (entry.isDir) navigate(entry.file)
+                                else {
+                                    try {
+                                        val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", entry.file)
+                                        context.startActivity(Intent(Intent.ACTION_VIEW).apply {
+                                            setDataAndType(uri, entry.file.name.mimeType())
+                                            clipData = ClipData.newRawUri("", uri)
+                                            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+                                        })
+                                    } catch (e: Exception) {
+                                        scope.launch { snackbarHostState.showSnackbar("No app can open this file") }
+                                    }
+                                }
+                            },
+                            onShare = {
+                                try {
+                                    val uri = FileProvider.getUriForFile(context, "${context.packageName}.fileprovider", entry.file)
+                                    context.startActivity(Intent.createChooser(Intent(Intent.ACTION_SEND).apply {
+                                        type = entry.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)
+                                    }, "Share").apply { addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) })
+                                } catch (_: Exception) {}
+                            },
+                        )
+                    }
+                    item { Spacer(Modifier.height(80.dp)) }
+                }
+            }
+        }
+
+        SnackbarHost(hostState = snackbarHostState, modifier = Modifier.align(Alignment.BottomCenter))
+    }
+}
+
+// ── Cloud file explorer ───────────────────────────────────────────────────────
+
+@Composable
+private fun CloudExplorer(
+    vm: FilesViewModel,
+    selectedAccountId: Long,
+    onAccountSelect: (Long) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val accounts by vm.accounts.collectAsState()
+    val cloudVm: RemoteBrowserViewModel = hiltViewModel(key = "cloud_explorer")
+    val state by cloudVm.state.collectAsState()
+    val breadcrumbState = rememberLazyListState()
+    val scope = rememberCoroutineScope()
+    var searchQuery by remember { mutableStateOf("") }
+    var searchActive by remember { mutableStateOf(false) }
+
+    LaunchedEffect(selectedAccountId) {
+        if (selectedAccountId != -1L) cloudVm.init(selectedAccountId, "/")
+    }
+
+    LaunchedEffect(state.currentPath) {
+        val segs = state.currentPath.trimEnd('/').split('/').filter { it.isNotEmpty() }
+        scope.launch { breadcrumbState.animateScrollToItem(maxOf(0, segs.size)) }
+        searchQuery = ""; searchActive = false
+    }
+
+    BackHandler(enabled = state.pathStack.size > 1) { cloudVm.navigateUp() }
+
+    if (accounts.isEmpty()) {
+        Box(modifier = modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+            Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                Icon(Icons.Default.CloudOff, null, Modifier.size(56.dp),
+                    tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f))
+                Spacer(Modifier.height(12.dp))
+                Text("No cloud accounts", style = MaterialTheme.typography.bodyLarge,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant)
+                Text("Add an account in Settings", style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.6f))
+            }
+        }
+        return
+    }
+
+    val segments = state.currentPath.trimEnd('/').split('/').filter { it.isNotEmpty() }
+    val filtered = if (searchQuery.isBlank()) state.entries
+    else state.entries.filter { it.name.contains(searchQuery, ignoreCase = true) }
+
+    Column(modifier = modifier) {
+
+        // ── Account chips ─────────────────────────────────────────────────────
+        if (accounts.size > 1) {
+            LazyRow(
+                contentPadding = PaddingValues(horizontal = 12.dp, vertical = 8.dp),
+                horizontalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                items(accounts) { acct ->
+                    FilterChip(
+                        selected = acct.id == selectedAccountId,
+                        onClick = { onAccountSelect(acct.id); cloudVm.init(acct.id, "/") },
+                        label = { Text(acct.displayName, maxLines = 1) },
+                        leadingIcon = { Icon(Icons.Default.Cloud, null, Modifier.size(14.dp)) },
+                    )
+                }
+            }
+            HorizontalDivider()
+        }
+
+        // ── Breadcrumbs / search ──────────────────────────────────────────────
+        Surface(tonalElevation = 1.dp) {
+            if (searchActive) {
+                val focusRequester = remember { FocusRequester() }
+                LaunchedEffect(Unit) { focusRequester.requestFocus() }
+                Row(
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 4.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    OutlinedTextField(
+                        value = searchQuery, onValueChange = { searchQuery = it },
+                        modifier = Modifier.weight(1f).focusRequester(focusRequester),
+                        placeholder = { Text("Search in folder…") }, singleLine = true,
+                        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
+                        keyboardActions = KeyboardActions(onSearch = {}),
+                        colors = OutlinedTextFieldDefaults.colors(
+                            focusedBorderColor = Color.Transparent, unfocusedBorderColor = Color.Transparent,
+                        ),
+                    )
+                    IconButton(onClick = { searchActive = false; searchQuery = "" }) { Icon(Icons.Default.Close, null) }
+                }
+            } else {
+                LazyRow(
+                    state = breadcrumbState,
+                    modifier = Modifier.fillMaxWidth().padding(horizontal = 8.dp, vertical = 6.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(2.dp),
+                ) {
+                    item { BreadcrumbChip("☁ Root", segments.isEmpty()) { cloudVm.navigateToBreadcrumb("/") } }
+                    itemsIndexed(segments) { idx, seg ->
+                        Icon(Icons.Default.ChevronRight, null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                        val segPath = "/" + segments.take(idx + 1).joinToString("/")
+                        BreadcrumbChip(seg, idx == segments.lastIndex) { cloudVm.navigateToBreadcrumb(segPath) }
+                    }
+                    item {
+                        Spacer(Modifier.width(4.dp))
+                        IconButton(onClick = { searchActive = true }, modifier = Modifier.size(28.dp)) {
+                            Icon(Icons.Default.Search, null, Modifier.size(18.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant)
+                        }
+                    }
+                }
+            }
+        }
+        HorizontalDivider()
+
+        // ── Content ───────────────────────────────────────────────────────────
+        Box(modifier = Modifier.weight(1f)) {
+            when {
+                state.isLoading -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                    CircularProgressIndicator()
+                }
+                state.error != null -> Column(
+                    modifier = Modifier.fillMaxSize().padding(32.dp),
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                    verticalArrangement = Arrangement.Center,
+                ) {
+                    Icon(Icons.Default.CloudOff, null, Modifier.size(56.dp), tint = MaterialTheme.colorScheme.error)
+                    Spacer(Modifier.height(12.dp))
+                    Text(state.error!!, color = MaterialTheme.colorScheme.error, style = MaterialTheme.typography.bodyMedium)
+                    Spacer(Modifier.height(16.dp))
+                    FilledTonalButton(onClick = cloudVm::retry) {
+                        Icon(Icons.Default.Refresh, null, Modifier.size(18.dp))
+                        Spacer(Modifier.width(6.dp))
+                        Text("Retry")
+                    }
+                }
+                filtered.isEmpty() -> Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
+                        Icon(Icons.Default.FolderOpen, null, Modifier.size(56.dp),
+                            tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.4f))
+                        Spacer(Modifier.height(12.dp))
+                        Text(
+                            if (searchQuery.isBlank()) "Empty folder" else "No results for \"$searchQuery\"",
+                            style = MaterialTheme.typography.bodyLarge,
+                            color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        )
+                    }
+                }
+                else -> LazyColumn(modifier = Modifier.fillMaxSize()) {
+                    items(filtered, key = { it.path }) { entry ->
+                        CloudFileItem(
+                            file = entry,
+                            onClick = {
+                                if (entry.isDirectory) cloudVm.navigateTo(entry.path)
+                                else vm.openCloudFile(selectedAccountId, entry.path)
+                            },
+                        )
+                    }
+                    item { Spacer(Modifier.height(80.dp)) }
+                }
+            }
+        }
+    }
+}
+
+// ── Shared UI components ──────────────────────────────────────────────────────
+
+@Composable
+private fun BreadcrumbChip(label: String, isLast: Boolean, onClick: () -> Unit) {
+    if (isLast) {
+        Surface(shape = RoundedCornerShape(8.dp), color = MaterialTheme.colorScheme.primaryContainer) {
+            Text(label, modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp),
+                style = MaterialTheme.typography.labelMedium, fontWeight = FontWeight.SemiBold,
+                color = MaterialTheme.colorScheme.onPrimaryContainer, maxLines = 1)
+        }
+    } else {
+        TextButton(onClick = onClick, contentPadding = PaddingValues(horizontal = 8.dp, vertical = 2.dp)) {
+            Text(label, style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.primary, maxLines = 1)
+        }
+    }
+}
+
+@Composable
+private fun LocalFileItem(entry: LocalEntry, onClick: () -> Unit, onShare: () -> Unit) {
+    var menuExpanded by remember { mutableStateOf(false) }
+    Row(
+        modifier = Modifier.fillMaxWidth().clickable(onClick = onClick).padding(horizontal = 16.dp, vertical = 10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(14.dp),
+    ) {
+        Box(
+            modifier = Modifier.size(46.dp).clip(RoundedCornerShape(12.dp)).background(
+                if (entry.isDir) Color(0xFF1B5E20).copy(alpha = 0.12f) else Color(0xFF0D47A1).copy(alpha = 0.10f)
+            ),
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(
+                imageVector = if (entry.isDir) Icons.Default.Folder else fileIcon(entry.file.name),
+                contentDescription = null, modifier = Modifier.size(26.dp),
+                tint = if (entry.isDir) Color(0xFF2E7D32) else Color(0xFF1565C0),
+            )
+        }
+        Column(modifier = Modifier.weight(1f)) {
+            Text(entry.file.name, style = MaterialTheme.typography.bodyLarge, maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                fontWeight = if (entry.isDir) FontWeight.Medium else FontWeight.Normal)
+            Text(
+                if (entry.isDir) "${entry.childCount} item${if (entry.childCount != 1) "s" else ""}"
+                else entry.sizeBytes.toDisplaySize(),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+        if (entry.isDir) {
+            Icon(Icons.Default.ChevronRight, null, Modifier.size(20.dp),
+                tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f))
+        } else {
+            Box {
+                IconButton(onClick = { menuExpanded = true }, modifier = Modifier.size(36.dp)) {
+                    Icon(Icons.Default.MoreVert, null, 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; onClick() })
+                    DropdownMenuItem(text = { Text("Share") }, leadingIcon = { Icon(Icons.Default.Share, null) },
+                        onClick = { menuExpanded = false; onShare() })
+                }
+            }
+        }
+    }
+    HorizontalDivider(modifier = Modifier.padding(start = 76.dp), thickness = 0.5.dp)
+}
+
+@Composable
+private fun CloudFileItem(file: com.syncflow.domain.model.RemoteFile, onClick: () -> Unit) {
+    Row(
+        modifier = Modifier.fillMaxWidth().clickable(onClick = onClick).padding(horizontal = 16.dp, vertical = 10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(14.dp),
+    ) {
+        Box(
+            modifier = Modifier.size(46.dp).clip(RoundedCornerShape(12.dp)).background(
+                if (file.isDirectory) Color(0xFF1B5E20).copy(alpha = 0.12f) else Color(0xFF0D47A1).copy(alpha = 0.10f)
+            ),
+            contentAlignment = Alignment.Center,
+        ) {
+            Icon(
+                imageVector = if (file.isDirectory) Icons.Default.Folder else fileIcon(file.name),
+                contentDescription = null, modifier = Modifier.size(26.dp),
+                tint = if (file.isDirectory) Color(0xFF2E7D32) else Color(0xFF1565C0),
+            )
+        }
+        Column(modifier = Modifier.weight(1f)) {
+            Text(file.name, style = MaterialTheme.typography.bodyLarge, maxLines = 1,
+                overflow = TextOverflow.Ellipsis,
+                fontWeight = if (file.isDirectory) FontWeight.Medium else FontWeight.Normal)
+            if (!file.isDirectory) {
+                Text(file.sizeBytes.toDisplaySize(), style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant)
+            }
+        }
+        if (file.isDirectory) {
+            Icon(Icons.Default.ChevronRight, null, Modifier.size(20.dp),
+                tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f))
+        } else {
+            Icon(Icons.Default.FileDownload, null, Modifier.size(20.dp),
+                tint = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = 0.5f))
+        }
+    }
+    HorizontalDivider(modifier = Modifier.padding(start = 76.dp), thickness = 0.5.dp)
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+private fun String.mimeType(): String {
+    val ext = substringAfterLast('.', "").lowercase()
+    return MimeTypeMap.getSingleton().getMimeTypeFromExtension(ext) ?: "*/*"
+}
+
+private fun fileIcon(name: String): ImageVector = 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,269 @@
+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())
+
+    val accounts = accountRepository.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}"
+
+    fun openCloudFile(accountId: Long, remotePath: String) {
+        viewModelScope.launch {
+            val account = accountRepository.getAccount(accountId) ?: run {
+                _fileAction.emit(FileAction.Error("Account not found"))
+                return@launch
+            }
+            val provider = providerFactory.create(account)
+            val fileName = remotePath.substringAfterLast('/')
+            val cacheFile = File(context.cacheDir, "syncflow_open/$fileName")
+            cacheFile.parentFile?.mkdirs()
+            _isDownloading.value = true
+            try {
+                cacheFile.outputStream().use { out ->
+                    provider.downloadFile(remotePath, out) { }.getOrThrow()
+                }
+                _fileAction.emit(FileAction.Open(cacheFile))
+            } catch (e: Exception) {
+                Timber.e(e, "Cloud open failed: $remotePath")
+                _fileAction.emit(FileAction.Error("Cannot open: ${e.message}"))
+            } finally {
+                _isDownloading.value = false
+            }
+        }
+    }
+
+    // ── 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/home/HomeScreen.kt

@@ -24,6 +24,7 @@ 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 com.syncflow.ui.shared.SyncProgress
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
@@ -38,6 +39,7 @@ fun HomeScreen(
     vm: HomeViewModel = hiltViewModel(),
 ) {
     val pairs by vm.syncPairs.collectAsState()
+    val progressMap by vm.syncProgressMap.collectAsState()
 
     if (pairs.isEmpty()) {
         EmptyState(modifier = modifier.fillMaxSize(), onAdd = onAddPair)
@@ -50,9 +52,11 @@ fun HomeScreen(
             items(pairs, key = { it.id }) { pair ->
                 SyncPairCard(
                     pair = pair,
+                    progress = progressMap[pair.id],
                     onClick = { onPairClick(pair.id) },
                     onSync = { vm.triggerSync(pair) },
                     onToggle = { vm.toggleEnabled(pair) },
+                    onPause = { vm.pauseSync(pair) },
                 )
             }
             item { Spacer(Modifier.height(80.dp)) }
@@ -63,9 +67,11 @@ fun HomeScreen(
 @Composable
 private fun SyncPairCard(
     pair: SyncPairEntity,
+    progress: SyncProgress? = null,
     onClick: () -> Unit,
     onSync: () -> Unit,
     onToggle: () -> Unit,
+    onPause: () -> Unit = {},
 ) {
     val accentColor = pair.lastSyncResult.accentColor
 
@@ -170,13 +176,57 @@ private fun SyncPairCard(
                         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).graphicsLayer {
-                                if (pair.lastSyncResult == SyncStatus.SYNCING) rotationZ = syncRotation
-                            },
-                        )
+                    when (pair.lastSyncResult) {
+                        SyncStatus.SYNCING -> FilledTonalIconButton(onClick = onPause, modifier = Modifier.size(36.dp)) {
+                            Icon(Icons.Default.Pause, "Pause sync", modifier = Modifier.size(18.dp))
+                        }
+                        SyncStatus.PAUSED -> FilledTonalIconButton(onClick = onSync, modifier = Modifier.size(36.dp), enabled = pair.isEnabled) {
+                            Icon(Icons.Default.PlayArrow, "Resume sync", modifier = Modifier.size(18.dp))
+                        }
+                        else -> FilledTonalIconButton(onClick = onSync, modifier = Modifier.size(36.dp)) {
+                            Icon(Icons.Default.Sync, "Sync now", modifier = Modifier.size(18.dp).graphicsLayer { rotationZ = syncRotation * 0f })
+                        }
+                    }
+                }
+
+                val displayProgress = when {
+                    pair.lastSyncResult == SyncStatus.SYNCING -> progress
+                    pair.lastSyncUploaded > 0 || pair.lastSyncDownloaded > 0 || pair.lastSyncDeleted > 0 ->
+                        SyncProgress(pair.lastSyncUploaded, pair.lastSyncDownloaded, pair.lastSyncDeleted, pair.lastSyncBytesTransferred)
+                    else -> null
+                }
+                if (pair.lastSyncResult == SyncStatus.SYNCING && displayProgress == null) {
+                    Text(
+                        "Starting…",
+                        style = MaterialTheme.typography.labelSmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                        modifier = Modifier.padding(top = 4.dp),
+                    )
+                } else if (displayProgress != null) {
+                    Row(
+                        modifier = Modifier.padding(top = 4.dp),
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(4.dp),
+                    ) {
+                        if (displayProgress.uploaded > 0) {
+                            Icon(Icons.Default.ArrowUpward, null, Modifier.size(11.dp), tint = MaterialTheme.colorScheme.primary)
+                            Text("${displayProgress.uploaded}", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.primary)
+                        }
+                        if (displayProgress.downloaded > 0) {
+                            Icon(Icons.Default.ArrowDownward, null, Modifier.size(11.dp), tint = MaterialTheme.colorScheme.secondary)
+                            Text("${displayProgress.downloaded}", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.secondary)
+                        }
+                        if (displayProgress.deleted > 0) {
+                            Icon(Icons.Default.DeleteOutline, null, Modifier.size(11.dp), tint = MaterialTheme.colorScheme.error)
+                            Text("${displayProgress.deleted}", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.error)
+                        }
+                        if (displayProgress.bytesTransferred > 0) {
+                            Text(
+                                "· ${displayProgress.bytesTransferred.toDisplaySize()}",
+                                style = MaterialTheme.typography.labelSmall,
+                                color = MaterialTheme.colorScheme.onSurfaceVariant,
+                            )
+                        }
                     }
                 }
             }
@@ -189,6 +239,7 @@ 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.PAUSED   -> Pair(Icons.Default.Pause, "Paused")
         SyncStatus.FAILED   -> Pair(Icons.Default.Error, "Failed")
         SyncStatus.CONFLICT -> Pair(Icons.Default.Warning, "Conflict")
         SyncStatus.PARTIAL  -> Pair(Icons.Default.WarningAmber, "Partial")
@@ -245,14 +296,22 @@ private fun EmptyState(modifier: Modifier = Modifier, onAdd: () -> Unit) {
     }
 }
 
+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"
+}
+
 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
+        SyncStatus.SUCCESS  -> Color(0xFF2E7D32)
+        SyncStatus.SYNCING  -> Color(0xFF1565C0)
+        SyncStatus.PAUSED   -> Color(0xFF6A1B9A)
+        SyncStatus.FAILED   -> Color(0xFFC62828)
+        SyncStatus.PARTIAL  -> Color(0xFFE65100)
+        SyncStatus.CONFLICT -> Color(0xFFF9A825)
+        SyncStatus.IDLE     -> MaterialTheme.colorScheme.outline
     }
 
 private fun String.toDisplayPath(): String {

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

@@ -4,15 +4,20 @@ import android.content.Context
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.WorkInfo
 import androidx.work.WorkManager
+import androidx.work.WorkQuery
 import com.syncflow.data.db.SyncPairDao
 import com.syncflow.data.db.entities.SyncPairEntity
 import com.syncflow.domain.model.ScheduleType
+import com.syncflow.domain.model.SyncStatus
+import com.syncflow.ui.shared.SyncProgress
 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.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -27,11 +32,33 @@ class HomeViewModel @Inject constructor(
     val syncPairs = syncPairDao.observeAll()
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())
 
+    val syncProgressMap: kotlinx.coroutines.flow.StateFlow<Map<Long, SyncProgress>> =
+        workManager.getWorkInfosFlow(WorkQuery.fromStates(WorkInfo.State.RUNNING))
+            .map { infos ->
+                infos
+                    .mapNotNull { info ->
+                        val tag = info.tags.firstOrNull { it.startsWith("sync_") } ?: return@mapNotNull null
+                        val pairId = tag.removePrefix("sync_").toLongOrNull() ?: return@mapNotNull null
+                        val up = info.progress.getInt(SyncWorker.KEY_PROGRESS_UPLOADED, 0)
+                        val down = info.progress.getInt(SyncWorker.KEY_PROGRESS_DOWNLOADED, 0)
+                        val del = info.progress.getInt(SyncWorker.KEY_PROGRESS_DELETED, 0)
+                        val bytes = info.progress.getLong(SyncWorker.KEY_PROGRESS_BYTES, 0L)
+                        if (up > 0 || down > 0 || del > 0) pairId to SyncProgress(up, down, del, bytes) else null
+                    }
+                    .toMap()
+            }
+            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyMap())
+
     fun triggerSync(pair: SyncPairEntity) {
         val req = SyncWorker.buildOneTimeRequest(pair.id, wifiOnly = false, chargingOnly = false)
         workManager.enqueue(req)
     }
 
+    fun pauseSync(pair: SyncPairEntity) {
+        workManager.cancelAllWorkByTag("sync_${pair.id}")
+        viewModelScope.launch { syncPairDao.updateStatus(pair.id, SyncStatus.PAUSED) }
+    }
+
     fun toggleEnabled(pair: SyncPairEntity) {
         viewModelScope.launch {
             val nowEnabled = !pair.isEnabled

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

@@ -0,0 +1,152 @@
+package com.syncflow.ui.log
+
+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.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
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+
+@Composable
+fun LogScreen(
+    modifier: Modifier = Modifier,
+    vm: LogViewModel = hiltViewModel(),
+) {
+    val entries by vm.entries.collectAsState()
+
+    if (entries.isEmpty()) {
+        Box(
+            modifier = modifier.fillMaxSize(),
+            contentAlignment = Alignment.Center,
+        ) {
+            Column(
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.spacedBy(8.dp),
+            ) {
+                Icon(
+                    Icons.Default.Notifications,
+                    contentDescription = null,
+                    modifier = Modifier.size(72.dp),
+                    tint = MaterialTheme.colorScheme.primary.copy(alpha = 0.35f),
+                )
+                Text("No activity yet", style = MaterialTheme.typography.titleMedium)
+                Text(
+                    "Sync events will appear here",
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+        }
+    } else {
+        LazyColumn(
+            modifier = modifier.fillMaxSize(),
+            contentPadding = PaddingValues(horizontal = 16.dp, vertical = 8.dp),
+            verticalArrangement = Arrangement.spacedBy(0.dp),
+        ) {
+            // Group entries by calendar date
+            val grouped = entries.groupBy { entry ->
+                entry.event.timestamp.atZone(ZoneId.systemDefault()).toLocalDate()
+            }
+            grouped.forEach { (date, dayEntries) ->
+                item(key = date.toString()) {
+                    Text(
+                        text = date.toRelativeLabel(),
+                        style = MaterialTheme.typography.labelMedium,
+                        color = MaterialTheme.colorScheme.primary,
+                        modifier = Modifier.padding(top = 16.dp, bottom = 4.dp),
+                    )
+                }
+                items(dayEntries, key = { it.event.id }) { entry ->
+                    LogEntryRow(entry)
+                    HorizontalDivider(
+                        color = MaterialTheme.colorScheme.outline.copy(alpha = 0.3f),
+                        modifier = Modifier.padding(start = 52.dp),
+                    )
+                }
+            }
+            item { Spacer(Modifier.height(80.dp)) }
+        }
+    }
+}
+
+@Composable
+private fun LogEntryRow(entry: LogEntry) {
+    val (icon, tint) = entry.event.eventType.iconAndTint()
+    val timeFmt = DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT)
+    val timeStr = entry.event.timestamp.atZone(ZoneId.systemDefault()).let { timeFmt.format(it) }
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 10.dp),
+        verticalAlignment = Alignment.Top,
+    ) {
+        // Icon bubble
+        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(
+                    entry.pairName,
+                    style = MaterialTheme.typography.labelMedium,
+                    color = MaterialTheme.colorScheme.primary,
+                    modifier = Modifier.weight(1f, fill = false),
+                )
+                Text(
+                    timeStr,
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+            }
+            Spacer(Modifier.height(2.dp))
+            Text(
+                text = entry.event.eventType.label(),
+                style = MaterialTheme.typography.bodySmall,
+            )
+            val detail = entry.event.filePath ?: entry.event.message
+            if (detail != null) {
+                Text(
+                    text = detail,
+                    style = MaterialTheme.typography.labelSmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    maxLines = 1,
+                )
+            }
+        }
+    }
+}
+
+private fun java.time.LocalDate.toRelativeLabel(): String {
+    val today = java.time.LocalDate.now()
+    return when {
+        this == today -> "Today"
+        this == today.minusDays(1) -> "Yesterday"
+        else -> DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).format(this)
+    }
+}

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

@@ -0,0 +1,29 @@
+package com.syncflow.ui.log
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.syncflow.data.db.SyncEventDao
+import com.syncflow.data.db.SyncPairDao
+import com.syncflow.data.db.entities.SyncEventEntity
+import dagger.hilt.android.lifecycle.HiltViewModel
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.stateIn
+import javax.inject.Inject
+
+data class LogEntry(val event: SyncEventEntity, val pairName: String)
+
+@HiltViewModel
+class LogViewModel @Inject constructor(
+    syncEventDao: SyncEventDao,
+    syncPairDao: SyncPairDao,
+) : ViewModel() {
+
+    val entries = combine(
+        syncEventDao.observeAll(500),
+        syncPairDao.observeAll(),
+    ) { events, pairs ->
+        val pairNames = pairs.associateBy({ it.id }, { it.name })
+        events.map { LogEntry(it, pairNames[it.syncPairId] ?: "Unknown") }
+    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5_000), emptyList())
+}

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

@@ -19,9 +19,13 @@ 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
 import androidx.compose.material3.*
 import androidx.compose.runtime.Composable
@@ -31,7 +35,9 @@ 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
 import kotlinx.coroutines.launch
 
@@ -42,7 +48,7 @@ fun MainShell(
     onPairClick: (Long) -> Unit,
     onAddAccount: () -> Unit,
 ) {
-    val pagerState = rememberPagerState(pageCount = { 2 })
+    val pagerState = rememberPagerState(pageCount = { 4 })
     val scope = rememberCoroutineScope()
     val currentPage = pagerState.currentPage
 
@@ -88,7 +94,29 @@ fun MainShell(
                     onClick = { scope.launch { pagerState.animateScrollToPage(1) } },
                     icon = {
                         Icon(
-                            if (currentPage == 1) Icons.Filled.ManageAccounts else Icons.Outlined.ManageAccounts,
+                            if (currentPage == 1) Icons.Filled.Notifications else Icons.Outlined.NotificationsNone,
+                            contentDescription = null,
+                        )
+                    },
+                    label = { Text("Log") },
+                )
+                NavigationBarItem(
+                    selected = currentPage == 2,
+                    onClick = { scope.launch { pagerState.animateScrollToPage(2) } },
+                    icon = {
+                        Icon(
+                            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,
                         )
                     },
@@ -120,7 +148,9 @@ fun MainShell(
         ) { page ->
             when (page) {
                 0 -> HomeScreen(onAddPair = onAddPair, onPairClick = onPairClick)
-                1 -> SettingsScreen(onAddAccount = onAddAccount)
+                1 -> LogScreen()
+                2 -> FilesScreen()
+                3 -> SettingsScreen(onAddAccount = onAddAccount)
             }
         }
     }

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

@@ -17,14 +17,13 @@ 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.SyncProgress
+import com.syncflow.ui.shared.SyncEventRow
 import java.time.Duration
 import java.time.Instant
 import java.time.ZoneId
@@ -42,6 +41,7 @@ fun PairDetailScreen(
     val pair by vm.pair.collectAsState()
     val events by vm.events.collectAsState()
     val conflictCount by vm.unresolvedConflicts.collectAsState()
+    val syncProgress by vm.syncProgress.collectAsState()
     var showDelete by remember { mutableStateOf(false) }
 
     if (showDelete) {
@@ -68,7 +68,17 @@ fun PairDetailScreen(
                 navigationIcon = { IconButton(onClick = onBack) { Icon(Icons.Default.ArrowBack, "Back") } },
                 actions = {
                     IconButton(onClick = { pair?.let { onEdit(it.id) } }) { Icon(Icons.Default.Edit, "Edit") }
-                    IconButton(onClick = { vm.syncNow() }) { Icon(Icons.Default.Sync, "Sync now") }
+                    when (pair?.lastSyncResult) {
+                        SyncStatus.SYNCING -> IconButton(onClick = { vm.pauseSync() }) {
+                            Icon(Icons.Default.Pause, "Pause sync")
+                        }
+                        SyncStatus.PAUSED -> IconButton(onClick = { vm.syncNow() }, enabled = pair?.isEnabled == true) {
+                            Icon(Icons.Default.PlayArrow, "Resume sync")
+                        }
+                        else -> IconButton(onClick = { vm.syncNow() }) {
+                            Icon(Icons.Default.Sync, "Sync now")
+                        }
+                    }
                     IconButton(onClick = { showDelete = true }) { Icon(Icons.Default.Delete, "Delete") }
                 },
             )
@@ -80,7 +90,7 @@ fun PairDetailScreen(
             verticalArrangement = Arrangement.spacedBy(12.dp),
         ) {
             item {
-                pair?.let { p -> StatusBanner(p) }
+                pair?.let { p -> StatusBanner(p, syncProgress) }
             }
 
             item {
@@ -132,7 +142,7 @@ fun PairDetailScreen(
                 }
             } else {
                 items(events, key = { it.id }) { event ->
-                    EventRow(event)
+                    SyncEventRow(event, showDivider = event != events.last())
                 }
             }
         }
@@ -140,10 +150,11 @@ fun PairDetailScreen(
 }
 
 @Composable
-private fun StatusBanner(pair: SyncPairEntity) {
+private fun StatusBanner(pair: SyncPairEntity, progress: SyncProgress? = null) {
     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.PAUSED   -> Triple(Icons.Default.Pause,       "Paused — tap ▶ to resume", MaterialTheme.colorScheme.surfaceVariant)
         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)
@@ -172,8 +183,39 @@ private fun StatusBanner(pair: SyncPairEntity) {
             Spacer(Modifier.width(16.dp))
             Column {
                 Text(label, style = MaterialTheme.typography.titleMedium)
-                pair.lastSyncAt?.let {
-                    Text(it.toRelativeString(), style = MaterialTheme.typography.bodySmall)
+                val displayProgress = when {
+                    pair.lastSyncResult == SyncStatus.SYNCING -> progress
+                    pair.lastSyncUploaded > 0 || pair.lastSyncDownloaded > 0 || pair.lastSyncDeleted > 0 ->
+                        SyncProgress(pair.lastSyncUploaded, pair.lastSyncDownloaded, pair.lastSyncDeleted, pair.lastSyncBytesTransferred)
+                    else -> null
+                }
+                if (pair.lastSyncResult == SyncStatus.SYNCING && displayProgress == null) {
+                    Text("Starting…", style = MaterialTheme.typography.bodySmall)
+                } else if (displayProgress != null) {
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.spacedBy(6.dp),
+                    ) {
+                        if (displayProgress.uploaded > 0) {
+                            Icon(Icons.Default.ArrowUpward, null, Modifier.size(12.dp))
+                            Text("${displayProgress.uploaded} up", style = MaterialTheme.typography.bodySmall)
+                        }
+                        if (displayProgress.downloaded > 0) {
+                            Icon(Icons.Default.ArrowDownward, null, Modifier.size(12.dp))
+                            Text("${displayProgress.downloaded} down", style = MaterialTheme.typography.bodySmall)
+                        }
+                        if (displayProgress.deleted > 0) {
+                            Icon(Icons.Default.DeleteOutline, null, Modifier.size(12.dp))
+                            Text("${displayProgress.deleted} del", style = MaterialTheme.typography.bodySmall)
+                        }
+                        if (displayProgress.bytesTransferred > 0) {
+                            Text("· ${displayProgress.bytesTransferred.toDisplaySize()}", style = MaterialTheme.typography.bodySmall)
+                        }
+                    }
+                } else {
+                    pair.lastSyncAt?.let {
+                        Text(it.toRelativeString(), style = MaterialTheme.typography.bodySmall)
+                    }
                 }
             }
         }
@@ -231,54 +273,11 @@ 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 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"
 }
 
 private fun String.toDisplayPath(): String {

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

@@ -3,13 +3,17 @@ package com.syncflow.ui.pairdetail
 import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import androidx.work.WorkInfo
 import androidx.work.WorkManager
 import com.syncflow.data.db.SyncConflictDao
 import com.syncflow.data.db.SyncEventDao
 import com.syncflow.data.db.SyncPairDao
+import com.syncflow.domain.model.SyncStatus
 import com.syncflow.worker.SyncWorker
 import dagger.hilt.android.lifecycle.HiltViewModel
+import com.syncflow.ui.shared.SyncProgress
 import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -34,11 +38,30 @@ class PairDetailViewModel @Inject constructor(
     val unresolvedConflicts = conflictDao.observeUnresolvedCount(pairId)
         .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), 0)
 
+    val syncProgress = workManager.getWorkInfosByTagFlow("sync_$pairId")
+        .map { infos ->
+            infos.firstOrNull { it.state == WorkInfo.State.RUNNING }?.progress?.let { data ->
+                SyncProgress(
+                    uploaded = data.getInt(SyncWorker.KEY_PROGRESS_UPLOADED, 0),
+                    downloaded = data.getInt(SyncWorker.KEY_PROGRESS_DOWNLOADED, 0),
+                    deleted = data.getInt(SyncWorker.KEY_PROGRESS_DELETED, 0),
+                    bytesTransferred = data.getLong(SyncWorker.KEY_PROGRESS_BYTES, 0L),
+                ).takeIf { it.uploaded > 0 || it.downloaded > 0 || it.deleted > 0 }
+            }
+        }
+        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), null)
+
     fun syncNow() {
         val p = pair.value ?: return
         workManager.enqueue(SyncWorker.buildOneTimeRequest(p.id, wifiOnly = false, chargingOnly = false))
     }
 
+    fun pauseSync() {
+        val p = pair.value ?: return
+        workManager.cancelAllWorkByTag("sync_${p.id}")
+        viewModelScope.launch { syncPairDao.updateStatus(p.id, SyncStatus.PAUSED) }
+    }
+
     fun delete() {
         viewModelScope.launch {
             pair.value?.let { syncPairDao.delete(it) }

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/shared/SyncProgress.kt

@@ -0,0 +1,3 @@
+package com.syncflow.ui.shared
+
+data class SyncProgress(val uploaded: Int, val downloaded: Int, val deleted: Int, val bytesTransferred: Long)

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

@@ -10,15 +10,23 @@ import android.os.FileObserver
 import android.os.Handler
 import android.os.IBinder
 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.data.db.entities.toDomain
 import com.syncflow.domain.model.ScheduleType
+import com.syncflow.domain.sync.LocalAccessor
 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
@@ -27,13 +35,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"
@@ -72,7 +89,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 }
 
@@ -81,39 +98,29 @@ class FileWatchService : Service() {
             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)
-                    }
+                // Try to resolve the SAF tree URI to a real filesystem path so we can use
+                // FileObserver. ContentObserver on a DocumentsProvider tree URI only fires
+                // when changes come through the SAF API, not for raw filesystem writes.
+                val realPath = safTreeUriToRealPath(localPath)
+                if (realPath != null) {
+                    watchPath(realPath, 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)
+                    // Fallback: register a ContentObserver for SAF paths that can't be resolved
+                    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 (ContentObserver fallback) for pair $pairId")
                 }
-                observer.startWatching()
-                fileObservers[pairId] = observer
-                Timber.d("FileWatchService: watching filesystem path for pair $pairId: $localPath")
+            } else {
+                watchPath(localPath, pairId, pair.wifiOnly, pair.chargingOnly)
             }
         }
 
-        val count = fileObservers.size + contentObservers.size
+        val count = fileObservers.keys.size + contentObservers.size
         updateNotification(count)
 
         if (count == 0) {
@@ -122,26 +129,212 @@ class FileWatchService : Service() {
         }
     }
 
+    private fun safTreeUriToRealPath(uriString: String): String? {
+        return try {
+            val treeUri = Uri.parse(uriString)
+            val docId = DocumentsContract.getTreeDocumentId(treeUri)
+            // docId format is "primary:RelativePath" for primary internal storage
+            if (docId.startsWith("primary:")) {
+                val relative = docId.removePrefix("primary:")
+                "/storage/emulated/0/$relative"
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            Timber.w("FileWatchService: could not resolve SAF URI to real path: $e")
+            null
+        }
+    }
+
+    private fun watchPath(path: String, pairId: Long, wifiOnly: Boolean, chargingOnly: Boolean) {
+        val dir = File(path)
+        if (!dir.exists()) {
+            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, 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(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.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 pairEntity = syncPairDao.getById(pairId) ?: return
+        val pair = pairEntity.toDomain()
+        // Use the same accessor + filters as SyncEngine so hidden/excluded/size-filtered files
+        // don't appear as "new" in the catchup scan and trigger a perpetual sync loop.
+        val accessor = if (pair.localPath.startsWith("content://"))
+            LocalAccessor.Saf(Uri.parse(pair.localPath), contentResolver)
+        else
+            LocalAccessor.JavaFile(dir)
+        val current = accessor.walkFiles(pair)
+
+        val hasNew      = current.any { (rel, _) -> rel !in known }
+        val hasModified = current.any { (rel, info) ->
+            val s = known[rel]; s != null && s.localModifiedAt != null &&
+            s.localModifiedAt.epochSecond != info.lastModifiedMs / 1000
+        }
+        val hasDeleted  = known.keys.any { rel -> rel !in current }
+
+        if (hasNew || hasModified || hasDeleted) {
+            Timber.d("FileWatchService: catchup detected changes for pair $pairId, scheduling sync")
+            // 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() {
@@ -156,7 +349,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 },
@@ -165,7 +358,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)
@@ -179,4 +372,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,15 +39,32 @@ 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…"))
 
         return try {
             val domainPair = pair.toDomain()
             val provider = providerFactory.create(account)
-            val result = syncEngine.sync(domainPair, provider)
+            val result = syncEngine.sync(domainPair, provider) { up, down, del, bytes ->
+                setProgress(workDataOf(
+                    KEY_PROGRESS_UPLOADED to up,
+                    KEY_PROGRESS_DOWNLOADED to down,
+                    KEY_PROGRESS_DELETED to del,
+                    KEY_PROGRESS_BYTES to bytes,
+                ))
+            }
 
-            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 +72,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 +163,25 @@ 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"
+        const val KEY_PROGRESS_UPLOADED = "prog_up"
+        const val KEY_PROGRESS_DOWNLOADED = "prog_down"
+        const val KEY_PROGRESS_DELETED = "prog_del"
+        const val KEY_PROGRESS_BYTES = "prog_bytes"
         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 +0,0 @@
-<?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

@@ -1,70 +0,0 @@
-<?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-anydpi-v26/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="@drawable/ic_launcher_background"/>
+    <background android:drawable="@color/ic_launcher_background"/>
     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

app/src/main/res/mipmap-anydpi-v26/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="@drawable/ic_launcher_background"/>
+    <background android:drawable="@color/ic_launcher_background"/>
     <foreground android:drawable="@drawable/ic_launcher_foreground"/>
 </adaptive-icon>

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

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

app/src/main/res/values/colors.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <color name="ic_launcher_background">#2196F3</color>
+    <color name="ic_launcher_background">#050E05</color>
 </resources>

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>

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

@@ -0,0 +1,36 @@
+package com.syncflow.domain.sync
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Path-traversal guard: a hostile/compromised remote must not be able to make the engine read
+ * or write outside the sync root via "..", absolute, or separator-smuggled paths.
+ */
+class PathSafetyTest {
+
+    @Test fun `normal relative paths are allowed`() {
+        assertFalse(isUnsafeSyncPath("photo.jpg"))
+        assertFalse(isUnsafeSyncPath("sub/dir/photo.jpg"))
+        assertFalse(isUnsafeSyncPath("a.b..c/file.txt")) // ".." only inside a name, not a segment
+    }
+
+    @Test fun `parent-dir traversal is rejected`() {
+        assertTrue(isUnsafeSyncPath(".."))
+        assertTrue(isUnsafeSyncPath("../evil"))
+        assertTrue(isUnsafeSyncPath("a/../../etc/passwd"))
+        assertTrue(isUnsafeSyncPath("sub/../../escape"))
+    }
+
+    @Test fun `backslash traversal is rejected`() {
+        assertTrue(isUnsafeSyncPath("..\\evil"))
+        assertTrue(isUnsafeSyncPath("a\\..\\..\\escape"))
+    }
+
+    @Test fun `absolute and empty paths are rejected`() {
+        assertTrue(isUnsafeSyncPath("/etc/passwd"))
+        assertTrue(isUnsafeSyncPath(""))
+        assertTrue(isUnsafeSyncPath("   "))
+    }
+}

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

@@ -91,10 +91,19 @@ class SyncDecideTest {
             decide(local(ts), remote(ts, etag = "e"), state(localMs = ts, remoteMs = ts, etag = "e")))
     }
 
-    @Test fun `1ms difference detected as local change`() {
+    @Test fun `sub-second mtime difference treated as unchanged`() {
+        // Second-precision comparison is intentional: FAT32 has 2s mtime resolution and WebDAV
+        // 1s, so sub-second deltas are phantom changes that caused rewrite loops. A 1ms diff
+        // within the same second must NOT be treated as a change.
+        val ts = 1_716_393_136_789L
+        assertEquals(SyncDecision.SKIP,
+            decide(local(ts + 1), remote(ts, etag = "e"), state(localMs = ts, remoteMs = ts, etag = "e")))
+    }
+
+    @Test fun `mtime change of a full second 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")))
+            decide(local(ts + 1000), remote(ts, etag = "e"), state(localMs = ts, remoteMs = ts, etag = "e")))
     }
 
     @Test fun `epoch-second stored value differs from millis comparison`() {
@@ -127,12 +136,14 @@ class SyncDecideTest {
         assertEquals(SyncDecision.SKIP,
             decide(null, remote(), state(), dir = SyncDirection.DOWNLOAD_ONLY))
 
-    // ── local deleted, no state record (uploaded in broken version) ──────────
+    // ── remote exists, no state record: never delete on ambiguity ────────────
 
-    @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,
+    @Test fun `remote exists with no state record downloads rather than deleting`() =
+        // known=null can mean a brand-new remote file OR one whose state was lost. The engine
+        // cannot tell them apart, so it downloads rather than risk deleting a real file —
+        // worst case is a re-downloaded file, never a lost one. A file the user genuinely
+        // deleted locally still has its state record, which routes to DELETE_REMOTE.
+        assertEquals(SyncDecision.DOWNLOAD,
             decide(null, remote(), known = null, delete = DeleteBehavior.MIRROR, hasPriorState = true))
 
     @Test fun `initial sync remote only no prior state downloads`() =

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

@@ -0,0 +1,117 @@
+package com.syncflow.domain.sync
+
+import com.syncflow.data.db.entities.SyncFileStateEntity
+import com.syncflow.domain.model.ConflictStrategy
+import com.syncflow.domain.model.DeleteBehavior
+import com.syncflow.domain.model.RemoteFile
+import com.syncflow.domain.model.SyncDirection
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.time.Instant
+
+/**
+ * End-to-end decision lifecycle for the backup scenario:
+ *
+ *   "I back up my phone to the cloud, then I delete the file on the phone.
+ *    It must stay in the cloud."
+ *
+ * These walk the exact multi-cycle state the SyncEngine produces:
+ *   - a successful UPLOAD saves state with the local mtime known and remote metadata null
+ *     (SyncEngine.buildState(..., remoteAfterTransfer = null)),
+ *   - the next sync sees both sides present and unchanged, returns SKIP, and the SKIP branch
+ *     reconciles the record by filling in the remote metadata,
+ *   - then the local file is deleted and we assert what happens to the cloud copy.
+ *
+ * The decision is driven entirely by deleteBehavior, so each terminal case is asserted for
+ * KEEP, MIRROR, and ARCHIVE.
+ */
+class UploadBackupLifecycleTest {
+
+    private val T0 = 1_716_393_136_000L // exact second boundary
+
+    private fun local(ms: Long = T0, size: Long = 100L) =
+        LocalFileInfo("photo.jpg", size, ms)
+
+    private fun remote(ms: Long = T0, etag: String? = "etag1", size: Long = 100L) =
+        RemoteFile("backup/photo.jpg", "photo.jpg", false, size, Instant.ofEpochMilli(ms), etag, null)
+
+    /** Mirrors SyncEngine.buildState right after a successful UPLOAD: remote metadata still null. */
+    private fun stateAfterUpload(ms: Long = T0) = SyncFileStateEntity(
+        syncPairId = 1L, relativePath = "photo.jpg",
+        localModifiedAt = Instant.ofEpochMilli(ms), localSizeBytes = 100L, localHash = null,
+        remoteModifiedAt = null, remoteSizeBytes = 0L, remoteEtag = null,
+        lastSyncedAt = Instant.now(), syncedHash = null,
+    )
+
+    /** Mirrors the record after the next sync's SKIP reconciliation fills in remote metadata. */
+    private fun stateReconciled(ms: Long = T0, etag: String? = "etag1") = SyncFileStateEntity(
+        syncPairId = 1L, relativePath = "photo.jpg",
+        localModifiedAt = Instant.ofEpochMilli(ms), localSizeBytes = 100L, localHash = null,
+        remoteModifiedAt = Instant.ofEpochMilli(ms), remoteSizeBytes = 100L, remoteEtag = etag,
+        lastSyncedAt = Instant.now(), syncedHash = null,
+    )
+
+    private fun decide(
+        local: LocalFileInfo?,
+        remote: RemoteFile?,
+        known: SyncFileStateEntity?,
+        delete: DeleteBehavior,
+    ) = syncDecide(
+        SyncDirection.UPLOAD_ONLY, ConflictStrategy.KEEP_NEWEST, delete,
+        local, remote, known, hasPriorSyncState = known != null,
+    )
+
+    // ── Cycle 1: first backup uploads the file ───────────────────────────────
+
+    @Test fun `cycle 1 - first backup uploads regardless of delete behavior`() {
+        assertEquals(SyncDecision.UPLOAD, decide(local(), null, null, DeleteBehavior.KEEP))
+        assertEquals(SyncDecision.UPLOAD, decide(local(), null, null, DeleteBehavior.MIRROR))
+        assertEquals(SyncDecision.UPLOAD, decide(local(), null, null, DeleteBehavior.ARCHIVE))
+    }
+
+    // ── Cycle 2: file present on both sides, unchanged -> SKIP (no deletion) ──
+
+    @Test fun `cycle 2 - unchanged file skips right after upload (remote metadata still null)`() {
+        assertEquals(SyncDecision.SKIP, decide(local(), remote(), stateAfterUpload(), DeleteBehavior.KEEP))
+        assertEquals(SyncDecision.SKIP, decide(local(), remote(), stateAfterUpload(), DeleteBehavior.MIRROR))
+    }
+
+    @Test fun `cycle 2 - unchanged file skips once state is reconciled`() {
+        assertEquals(SyncDecision.SKIP, decide(local(), remote(), stateReconciled(), DeleteBehavior.KEEP))
+        assertEquals(SyncDecision.SKIP, decide(local(), remote(), stateReconciled(), DeleteBehavior.MIRROR))
+    }
+
+    // ── Cycle 3: deleted on the phone — THE scenario ─────────────────────────
+
+    @Test fun `KEEP - deleting on phone leaves the cloud copy (correct backup behavior)`() {
+        // Reconciled steady state:
+        assertEquals(SyncDecision.SKIP, decide(null, remote(), stateReconciled(), DeleteBehavior.KEEP))
+        // And even if deletion happens before the reconcile pass ran:
+        assertEquals(SyncDecision.SKIP, decide(null, remote(), stateAfterUpload(), DeleteBehavior.KEEP))
+    }
+
+    @Test fun `MIRROR - deleting on phone DELETES the cloud copy (wrong for a backup)`() {
+        assertEquals(SyncDecision.DELETE_REMOTE, decide(null, remote(), stateReconciled(), DeleteBehavior.MIRROR))
+        assertEquals(SyncDecision.DELETE_REMOTE, decide(null, remote(), stateAfterUpload(), DeleteBehavior.MIRROR))
+    }
+
+    @Test fun `ARCHIVE - deleting on phone moves the cloud copy to _Deleted (preserved)`() {
+        // syncDecide returns DELETE_REMOTE; the engine's DELETE_REMOTE branch MOVEs the file to
+        // <remote>/_Deleted/ instead of removing it when deleteBehavior == ARCHIVE.
+        assertEquals(SyncDecision.DELETE_REMOTE, decide(null, remote(), stateReconciled(), DeleteBehavior.ARCHIVE))
+    }
+
+    // ── After deletion: a brand-new remote file is NOT pulled down (upload-only) ─
+
+    @Test fun `KEEP - a new remote file never comes down to the phone (upload-only)`() {
+        // Remote-only, no state record: in upload-only this must SKIP, not DOWNLOAD.
+        assertEquals(SyncDecision.SKIP, decide(null, remote(), null, DeleteBehavior.KEEP))
+    }
+
+    // ── Re-adding / changing a file after a KEEP deletion still uploads ───────
+
+    @Test fun `KEEP - modifying the file locally still uploads the change`() {
+        val newer = local(T0 + 5_000)
+        assertEquals(SyncDecision.UPLOAD, decide(newer, remote(), stateReconciled(), DeleteBehavior.KEEP))
+    }
+}

app/src/test/kotlin/com/syncflow/ui/addpair/RecommendedDeleteBehaviorTest.kt

@@ -0,0 +1,23 @@
+package com.syncflow.ui.addpair
+
+import com.syncflow.domain.model.DeleteBehavior
+import com.syncflow.domain.model.SyncDirection
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * The Add-Pair screen's default deletion behaviour must never wipe a backup. One-way directions
+ * default to KEEP so deleting a file on the phone leaves the cloud copy intact; two-way defaults
+ * to MIRROR. (The user can still override to any of the three options.)
+ */
+class RecommendedDeleteBehaviorTest {
+
+    @Test fun `upload-only defaults to KEEP so backups are never deleted`() =
+        assertEquals(DeleteBehavior.KEEP, recommendedDeleteBehavior(SyncDirection.UPLOAD_ONLY))
+
+    @Test fun `download-only defaults to KEEP`() =
+        assertEquals(DeleteBehavior.KEEP, recommendedDeleteBehavior(SyncDirection.DOWNLOAD_ONLY))
+
+    @Test fun `two-way defaults to MIRROR`() =
+        assertEquals(DeleteBehavior.MIRROR, recommendedDeleteBehavior(SyncDirection.TWO_WAY))
+}

gradle/libs.versions.toml

@@ -28,8 +28,8 @@ localbroadcastmanager = "1.1.0"
 coil = "2.7.0"
 splashscreen = "1.0.1"
 timber = "5.0.1"
-securityCrypto = "1.1.0-alpha06"
-biometric = "1.2.0-alpha05"
+securityCrypto = "1.0.0"
+biometric = "1.1.0"
 junit = "4.13.2"
 androidxTestExt = "1.2.1"
 espresso = "3.6.1"
@@ -106,7 +106,7 @@ coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coi
 
 # Security
 security-crypto = { group = "androidx.security", name = "security-crypto", version.ref = "securityCrypto" }
-biometric = { group = "androidx.biometric", name = "biometric-ktx", version.ref = "biometric" }
+biometric = { group = "androidx.biometric", name = "biometric", version.ref = "biometric" }
 
 # Logging
 timber = { group = "com.jakewharton.timber", name = "timber", version.ref = "timber" }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=file\:///home/amir/gradle/gradle-8.6/gradle-8.6-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,2 +1,39 @@
-#!/bin/bash
-exec /home/amir/gradle/gradle-8.6/bin/gradle "$@"
+#!/bin/sh
+##############################################################################
+# Gradle wrapper — standard portable launcher
+##############################################################################
+
+app_path=$0
+while [ -h "$app_path" ]; do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in
+      /*)   app_path=$link ;;
+      *)    app_path=${app_path%"${app_path##*/}"}$link ;;
+    esac
+done
+APP_HOME=$( cd "${app_path%"${app_path##*/}"}." && pwd -P ) || exit
+
+APP_BASE_NAME=${0##*/}
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+if [ -n "$JAVA_HOME" ]; then
+    JAVACMD=$JAVA_HOME/bin/java
+else
+    JAVACMD=java
+fi
+
+MAX_FD=maximum
+case "$( uname )" in
+  Darwin*) ;;
+  *)
+    MAX_FD=$( ulimit -H -n 2>/dev/null ) && ulimit -n "$MAX_FD" 2>/dev/null ;;
+esac
+
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS \
+    "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" \
+    -classpath "\"$CLASSPATH\"" \
+    org.gradle.wrapper.GradleWrapperMain '"$@"'
+
+exec "$JAVACMD" "$@"

version.properties

@@ -1,2 +1,2 @@
-VERSION_NAME=1.0.18
-VERSION_CODE=19
+VERSION_NAME=1.0.71
+VERSION_CODE=71