v1.0.76: multi-folder backup (many folders -> one remote base, each its own subfolder)

Adds an opt-in 'Back up multiple folders' mode to Add Sync: pick N folders +
one remote base, and the app creates one normal pair per folder at
base/<folderName>. Each source keeps its own subfolder so same-named files
across folders never collide/overwrite — the safe many-to-one.

- AddPairViewModel: multiFolder + localPaths state, batch save via buildEntity;
  folderLeafName() + uniqueSubName() derive collision-free remote subfolders
- AddPairScreen: mode toggle (new pairs only), folder list w/ add/remove,
  remote-base labelling
- SyncEngine: first-sync against a not-yet-created remote folder no longer fails
  — treat 404 as empty remote ONLY when no prior state exists (no DELETE_* can
  fire), and MKCOL the base dir so first uploads have a parent. An established
  pair still fails loudly on 404 (never mass-deletes a vanished remote).
- Tests: MultiFolderTest, isRemoteNotFound cases in ExcludePathTest

.gitea/workflows/release.yml

@@ -2,12 +2,16 @@ 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
@@ -20,10 +24,29 @@ jobs:
 
       - uses: android-actions/setup-android@v3
 
-      - name: Build debug APK
+      - name: Run unit tests
         run: |
           chmod +x gradlew
-          ./gradlew assembleDebug --no-daemon
+          ./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
@@ -32,21 +55,27 @@ jobs:
       - name: Rename APK
         run: |
           mkdir dist
-          cp app/build/outputs/apk/debug/app-debug.apk \
+          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: |
-          RELEASE_ID=$(curl -sf \
-            "https://gitea.khodak.me/api/v1/repos/amir/SyncFlow/releases/tags/$TAG" \
-            -H "Authorization: token $TOKEN" \
-            | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])")
-          curl -sf -X POST \
-            "https://gitea.khodak.me/api/v1/repos/amir/SyncFlow/releases/$RELEASE_ID/assets" \
+          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"
+          echo "APK uploaded to release $TAG (id $RELEASE_ID)"

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/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

@@ -23,19 +23,36 @@ class SftpProvider(private val account: CloudAccount, private val credentialStor
     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(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()
+        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,7 +60,11 @@ class SftpProvider(private val account: CloudAccount, private val credentialStor
 
     override suspend fun listFiles(remotePath: String): Result<List<RemoteFile>> = runCatching {
         withSftp { sftp ->
-            sftp.ls(remotePath).map { entry ->
+            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,
@@ -63,12 +84,25 @@ class SftpProvider(private val account: CloudAccount, private val credentialStor
         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/webdav/WebDavProvider.kt

@@ -35,7 +35,8 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
         val pass = creds["password"]?.jsonPrimitive?.content ?: ""
         OkHttpClient.Builder()
             .connectTimeout(15, TimeUnit.SECONDS)
-            .readTimeout(30, TimeUnit.SECONDS)
+            .readTimeout(5, TimeUnit.MINUTES)
+            .writeTimeout(5, TimeUnit.MINUTES)
             .addInterceptor { chain ->
                 val req = chain.request().newBuilder()
                     .header("Authorization", Credentials.basic(user, pass))
@@ -93,15 +94,30 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
                     localStream.source().use { source -> sink.writeAll(source) }
                 }
             }
-            val req = Request.Builder().url(url(remotePath)).put(body).build()
+            // 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}")
             }
+            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()
@@ -134,7 +150,12 @@ open class WebDavProvider(protected val account: CloudAccount) : CloudProvider {
         withContext(Dispatchers.IO) {
             val req = Request.Builder().url(url(remotePath)).method("MKCOL", null).build()
             client.newCall(req).execute().use { resp ->
-                if (!resp.isSuccessful && resp.code != 405) throw Exception("MKCOL HTTP ${resp.code}")
+                // 405 = directory already exists (most servers)
+                // 423 = Locked — SFTPGo returns this when the dir exists and has a lock;
+                //       treat as "already there", not a failure, so uploads inside it proceed.
+                if (!resp.isSuccessful && resp.code != 405 && resp.code != 423) {
+                    throw Exception("MKCOL HTTP ${resp.code}")
+                }
             }
         }
     }
@@ -166,7 +187,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>()

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 ->
+            // Clear any leftover temp document from a previously interrupted write.
+            findChildId(childrenUri, tmpName)?.let { staleId ->
+                runCatching {
                     DocumentsContract.deleteDocument(
-                    resolver,
-                    DocumentsContract.buildDocumentUriUsingTree(treeUri, existingId)
+                        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

@@ -68,6 +68,36 @@ class SyncEngine @Inject constructor(
         else
             LocalAccessor.JavaFile(File(localPath))
 
+    /**
+     * 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,
@@ -76,8 +106,32 @@ class SyncEngine @Inject constructor(
     ): SyncResult {
         val accessor = makeAccessor(pair.localPath)
         var knownStates = fileStateDao.getForPair(pair.id).associateBy { it.relativePath }
-        val remoteFiles = provider.listFiles(pair.remotePath).getOrThrow()
+        // 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.
+        // Exclusions are filtered on BOTH sides. The local walk already drops excluded files,
+        // but the remote listing did not, so any excluded path that already existed on the
+        // server (e.g. a previously-uploaded ".thumbnails" entry) looked "local-missing" and
+        // got DELETE_REMOTE'd every cycle — endless churn as Android regenerates the cache.
+        // Filtering remote + the merged path set makes excluded paths invisible to the engine:
+        // never uploaded, downloaded, or deleted on either side.
+        val remoteFiles = try {
+            listRemoteFilesRecursive(provider, pair.remotePath)
                 .associateBy { it.path.removePrefix(pair.remotePath).trimStart('/') }
+                .filterKeys { !isExcludedPath(it, pair) }
+        } catch (e: Exception) {
+            // A brand-new pair whose remote folder doesn't exist yet 404s on the first listing —
+            // that simply means "empty remote", so everything uploads. This is ONLY safe with no
+            // prior sync state: on a first sync every known==null, so no DELETE_* branch can fire
+            // (verified in syncDecide). Once state exists, a 404 means the remote folder vanished
+            // or is unreachable, and treating it as empty would mirror-delete every local file —
+            // so we rethrow and let the sync fail loudly instead of destroying data.
+            if (knownStates.isEmpty() && isRemoteNotFound(e)) {
+                runCatching { ensureRemoteBaseDir(provider, pair.remotePath) }
+                emptyMap()
+            } else throw e
+        }
         val localFiles = accessor.walkFiles(pair)
 
         // Self-healing: if every known-state path is absent from the current local scan but
@@ -91,9 +145,14 @@ class SyncEngine @Inject constructor(
             return performSync(pair, provider, isRetry = true, onProgress = onProgress)
         }
 
-        val allPaths = (localFiles.keys + remoteFiles.keys + knownStates.keys).toSet()
+        // knownStates may still hold records for now-excluded paths (e.g. thumbnails uploaded
+        // by an older build). Drop them from the work set so they aren't acted on; their stale
+        // state rows are harmless and ignored.
+        val allPaths = (localFiles.keys + remoteFiles.keys + knownStates.keys)
+            .filter { !isExcludedPath(it, pair) }
+            .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)
@@ -111,6 +170,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]
@@ -142,8 +209,8 @@ class SyncEngine @Inject constructor(
                             }
                             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 ->
@@ -178,6 +245,10 @@ class SyncEngine @Inject constructor(
                                 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") }
@@ -240,6 +311,20 @@ class SyncEngine @Inject constructor(
         )
     }
 
+    /**
+     * Create every path component of the pair's remote root (e.g. /Backup/DCIM → MKCOL /Backup
+     * then /Backup/DCIM) so the first uploads of a brand-new pair have a parent to land in.
+     * Only called on a first sync where the root listing 404'd; existing-dir MKCOLs fail harmlessly.
+     */
+    private suspend fun ensureRemoteBaseDir(provider: CloudProvider, remotePath: String) {
+        val parts = remotePath.replace('\\', '/').split('/').filter { it.isNotEmpty() }
+        var current = ""
+        for (part in parts) {
+            current = "$current/$part"
+            provider.createDirectory(current).onFailure { e -> Timber.w("MKCOL base $current: ${e.message}") }
+        }
+    }
+
     private suspend fun ensureRemoteDirs(provider: CloudProvider, remotePairPath: String, rel: String) {
         val parts = rel.replace('\\', '/').split('/')
         var currentPath = remotePairPath
@@ -363,6 +448,76 @@ internal fun syncDecide(
 
 enum class SyncDecision { UPLOAD, DOWNLOAD, DELETE_LOCAL, DELETE_REMOTE, CONFLICT, SKIP }
 
+/**
+ * Heuristic: did a provider call fail because the remote path doesn't exist (HTTP 404)? Providers
+ * surface errors as exceptions carrying the HTTP status in the message, so we match on that. Used
+ * only to let a first-ever sync proceed against a not-yet-created remote folder (see performSync).
+ */
+internal fun isRemoteNotFound(e: Throwable): Boolean {
+    val m = (e.message ?: "").lowercase()
+    return "404" in m || "not found" in m || "notfound" in m
+}
+
+/**
+ * OS-generated, volatile paths that must NEVER sync on any pair, regardless of user exclude
+ * config. These are matched against every path SEGMENT (directory names included), so an entire
+ * subtree like "DCIM/.thumbnails/..." is ignored. Android continuously regenerates and evicts
+ * its thumbnail cache and shuffles files through .trashed-/.pending- staging dirs; syncing them
+ * produces an endless upload→evict→DELETE_REMOTE→regenerate loop. ".sfpart" is our own atomic-
+ * write temp suffix and must never be propagated either.
+ */
+private val ALWAYS_IGNORED_SEGMENTS = setOf(".thumbnails")
+private val ALWAYS_IGNORED_PREFIXES = listOf(".trashed-", ".pending-")
+private val ALWAYS_IGNORED_SUFFIXES = listOf(".sfpart")
+
+/**
+ * App-private storage trees. On Android 11+ (scoped storage) another app's SAF grant can LIST
+ * these directories but cannot OPEN the files inside, so every transfer fails and the pair is
+ * stuck reporting "Partial" forever (e.g. Android/media/com.whatsapp/...). They hold app-managed
+ * data, not user content worth syncing, so they are excluded entirely. Matched case-insensitively
+ * against the full relative path so the whole subtree is ignored on both sides.
+ */
+private val ALWAYS_IGNORED_PATH_PREFIXES = listOf("android/data/", "android/media/", "android/obb/")
+
+/**
+ * True if [rel] should be excluded from sync entirely. Applied symmetrically to the local walk,
+ * the remote listing, and known state so an excluded path is never uploaded, downloaded, or
+ * deleted. The always-ignored rules run on every segment; user-configured rules
+ * (skipHiddenFiles, excludePatterns, excludeExtensions) match the filename, mirroring the
+ * existing local-walk semantics in LocalAccessor.
+ */
+internal fun isExcludedPath(rel: String, pair: SyncPair): Boolean {
+    val normalized = rel.replace('\\', '/')
+    val lower = normalized.lowercase()
+    if (ALWAYS_IGNORED_PATH_PREFIXES.any { lower.startsWith(it) }) return true
+    val segments = normalized.split('/').filter { it.isNotEmpty() }
+    if (segments.isEmpty()) return false
+    for (seg in segments) {
+        if (seg in ALWAYS_IGNORED_SEGMENTS) return true
+        if (ALWAYS_IGNORED_PREFIXES.any { seg.startsWith(it) }) return true
+        if (ALWAYS_IGNORED_SUFFIXES.any { seg.endsWith(it) }) return true
+    }
+    val fileName = segments.last()
+    if (pair.skipHiddenFiles && fileName.startsWith('.')) return true
+    if (pair.excludePatterns.any { pat -> fileName.matches(globToRegex(pat)) }) return true
+    val ext = fileName.substringAfterLast('.', "").lowercase()
+    if (pair.excludeExtensions.any { ext == it.lowercase().trimStart('.') }) return true
+    return false
+}
+
+/**
+ * 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

@@ -5,6 +5,8 @@ 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
@@ -50,7 +52,7 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
         LocalBrowserDialog(
             initialPath = s.localPath.ifBlank { "" },
             onSelect = { path ->
-                vm.update { copy(localPath = path) }
+                if (s.multiFolder) vm.addLocalFolder(path) else vm.update { copy(localPath = path) }
                 showLocalBrowser = false
             },
             onDismiss = { showLocalBrowser = false },
@@ -92,7 +94,7 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
             Section(title = null) {
                 OutlinedTextField(
                     value = s.name, onValueChange = { vm.update { copy(name = it) } },
-                    label = { Text("Sync pair name") },
+                    label = { Text(if (s.multiFolder) "Group name prefix (optional)" else "Sync pair name") },
                     leadingIcon = { Icon(Icons.Default.DriveFileRenameOutline, null) },
                     singleLine = true, modifier = Modifier.fillMaxWidth(),
                     keyboardOptions = KeyboardOptions(imeAction = ImeAction.Next),
@@ -120,7 +122,40 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
 
                 Spacer(Modifier.height(4.dp))
 
-                // Local folder
+                // Multi-folder mode toggle (new pairs only — editing stays single-folder)
+                if (!s.isEditing) {
+                    ToggleRow(
+                        label = "Back up multiple folders",
+                        description = "Pick several folders; each is saved as its own subfolder under the remote base (no overwrites)",
+                        checked = s.multiFolder,
+                        onToggle = { vm.setMultiFolder(it) },
+                    )
+                    Spacer(Modifier.height(4.dp))
+                }
+
+                if (s.multiFolder) {
+                    // Chosen folders list
+                    s.localPaths.forEach { p ->
+                        Row(
+                            modifier = Modifier.fillMaxWidth().padding(vertical = 2.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Icon(Icons.Default.Folder, null, Modifier.size(18.dp), tint = MaterialTheme.colorScheme.primary)
+                            Spacer(Modifier.width(8.dp))
+                            Text(uriToDisplay(p), style = MaterialTheme.typography.bodyMedium,
+                                maxLines = 1, modifier = Modifier.weight(1f))
+                            IconButton(onClick = { vm.removeLocalFolder(p) }) {
+                                Icon(Icons.Default.Close, "Remove folder")
+                            }
+                        }
+                    }
+                    OutlinedButton(onClick = { showLocalBrowser = true }, modifier = Modifier.fillMaxWidth()) {
+                        Icon(Icons.Default.Add, null)
+                        Spacer(Modifier.width(6.dp))
+                        Text("Add folder")
+                    }
+                } else {
+                    // Single local folder
                     Box(modifier = Modifier.fillMaxWidth()) {
                         OutlinedTextField(
                             value = uriToDisplay(s.localPath), onValueChange = {},
@@ -132,11 +167,12 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
                         )
                         Box(modifier = Modifier.matchParentSize().clickable { showLocalBrowser = true })
                     }
+                }
 
-                // Remote folder
+                // Remote folder (base, in multi-folder mode)
                 OutlinedTextField(
                     value = s.remotePath, onValueChange = { vm.update { copy(remotePath = it) } },
-                    label = { Text("Remote folder") },
+                    label = { Text(if (s.multiFolder) "Remote base folder" else "Remote folder") },
                     leadingIcon = { Icon(Icons.Default.Cloud, null) },
                     trailingIcon = {
                         IconButton(
@@ -145,7 +181,7 @@ fun AddPairScreen(onDone: () -> Unit, vm: AddPairViewModel = hiltViewModel()) {
                         ) { Icon(Icons.Default.Folder, "Browse remote") }
                     },
                     singleLine = true, modifier = Modifier.fillMaxWidth(),
-                    placeholder = { Text("/ or /Documents/Photos") },
+                    placeholder = { Text(if (s.multiFolder) "/Backup — each folder becomes a subfolder" else "/ or /Documents/Photos") },
                 )
 
                 // Recursive
@@ -163,7 +199,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))
@@ -179,7 +215,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}" },
                 )
             }
@@ -382,10 +418,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

@@ -10,7 +10,10 @@ 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.*
@@ -22,13 +25,20 @@ data class AddPairUiState(
     val name: String = "",
     // ── Folders ──────────────────────────────────────────────────────────────
     val localPath: String = "",
+    // Multi-folder mode: pick several local folders that each back up to their own subfolder
+    // under one remote base. Empty unless multiFolder is on.
+    val multiFolder: Boolean = false,
+    val localPaths: List<String> = emptyList(),
     val remotePath: String = "",
     val selectedAccountId: Long = -1L,
     val accounts: List<CloudAccountEntity> = emptyList(),
     // ── 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,
@@ -41,7 +51,7 @@ data class AddPairUiState(
     val chargingOnly: Boolean = false,
     val minBatteryPct: Int = 0,
     // ── File filters ─────────────────────────────────────────────────────────
-    val excludePatterns: String = ".DS_Store\n*.tmp\n.nomedia\nThumbs.db",
+    val excludePatterns: String = ".DS_Store\n*.tmp\n.nomedia\nThumbs.db\n.thumbnails",
     val includeExtensions: String = "",
     val excludeExtensions: String = "",
     val skipHiddenFiles: Boolean = true,
@@ -51,11 +61,47 @@ data class AddPairUiState(
     val notifyOnComplete: Boolean = false,
     val notifyOnError: Boolean = true,
     // ── Form state ───────────────────────────────────────────────────────────
+    val isEditing: Boolean = false,
     val isSaving: Boolean = false,
     val error: String? = null,
     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
+}
+
+/**
+ * Last path component of a local folder path or SAF content:// tree URI, used as the remote
+ * subfolder name in multi-folder mode. Handles URL-encoded tree URIs
+ * (content://…/tree/primary%3ADCIM%2FCamera → "Camera") and plain filesystem paths.
+ */
+internal fun folderLeafName(path: String): String {
+    val decoded = try { java.net.URLDecoder.decode(path, "UTF-8") } catch (e: Exception) { path }
+    val afterColon = decoded.substringAfterLast(':')   // strip the "primary:" storage-volume prefix
+    val leaf = afterColon.trimEnd('/').substringAfterLast('/')
+    return leaf.ifBlank { "folder" }
+}
+
+/**
+ * Make a remote subfolder name unique within one multi-folder batch so two source folders that
+ * share a leaf name (e.g. DCIM/Camera and Movies/Camera) don't collide into one remote dir.
+ * Slashes are flattened to underscores; collisions get a numeric suffix.
+ */
+internal fun uniqueSubName(base: String, used: MutableSet<String>): String {
+    val clean = base.replace('/', '_').replace('\\', '_').ifBlank { "folder" }
+    if (used.add(clean)) return clean
+    var n = 2
+    while (!used.add("${clean}_$n")) n++
+    return "${clean}_$n"
+}
+
 @HiltViewModel
 class AddPairViewModel @Inject constructor(
     private val syncPairDao: SyncPairDao,
@@ -67,7 +113,7 @@ class AddPairViewModel @Inject constructor(
 
     private val editPairId = savedState.get<Long>("pairId").takeIf { it != -1L }
 
-    private val _state = MutableStateFlow(AddPairUiState())
+    private val _state = MutableStateFlow(AddPairUiState(isEditing = editPairId != null))
     val state = _state.asStateFlow()
 
     init {
@@ -86,6 +132,7 @@ class AddPairViewModel @Inject constructor(
                 syncPairDao.getById(id)?.let { pair ->
                     _state.update { _ ->
                         AddPairUiState(
+                            isEditing = true,
                             name = pair.name,
                             localPath = pair.localPath,
                             remotePath = pair.remotePath,
@@ -93,6 +140,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,
@@ -119,12 +167,37 @@ 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 setMultiFolder(enabled: Boolean) = _state.update { it.copy(multiFolder = enabled) }
+
+    fun addLocalFolder(path: String) = _state.update {
+        if (path.isBlank() || path in it.localPaths) it else it.copy(localPaths = it.localPaths + path)
+    }
+
+    fun removeLocalFolder(path: String) = _state.update { it.copy(localPaths = it.localPaths - path) }
+
     fun save() {
         val s = _state.value
         val errors = buildList {
+            if (s.multiFolder) {
+                if (s.localPaths.isEmpty()) add("Add at least one folder")
+                if (s.remotePath.isBlank()) add("Remote base folder is required")
+            } else {
                 if (s.name.isBlank()) add("Name is required")
                 if (s.localPath.isBlank()) add("Local folder is required")
                 if (s.remotePath.isBlank()) add("Remote folder is required")
+            }
             if (s.selectedAccountId == -1L) add("Select a cloud account")
             if (s.scheduleType == ScheduleType.INTERVAL && s.intervalMinutes < 15) add("Minimum interval is 15 minutes")
         }
@@ -133,9 +206,50 @@ class AddPairViewModel @Inject constructor(
         viewModelScope.launch {
             _state.update { it.copy(isSaving = true, error = null) }
             runCatching {
-                val entity = SyncPairEntity(
-                    id = editPairId ?: 0L,
-                    name = s.name, localPath = s.localPath, remotePath = s.remotePath,
+                if (s.multiFolder) {
+                    // One normal pair per folder, each into its OWN subfolder under the remote base.
+                    // Keeping each source in a distinct subfolder is what makes many-to-one safe —
+                    // flattening would let same-named files from different folders overwrite each other.
+                    val base = s.remotePath.trimEnd('/')
+                    val used = mutableSetOf<String>()
+                    s.localPaths.map { folder ->
+                        val sub = uniqueSubName(folderLeafName(folder), used)
+                        val pairName = if (s.name.isBlank()) sub else "${s.name} — $sub"
+                        val entity = buildEntity(s, name = pairName, localPath = folder, remotePath = "$base/$sub", id = 0L)
+                        entity.copy(id = syncPairDao.insert(entity))
+                    }
+                } else {
+                    val entity = buildEntity(s, name = s.name, localPath = s.localPath, remotePath = s.remotePath, id = editPairId ?: 0L)
+                    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
+                    }
+                    listOf(entity.copy(id = pairId))
+                }
+            }
+                .onSuccess { saved ->
+                    saved.forEach { applySchedule(it) }
+                    _state.update { it.copy(done = true) }
+                }
+                .onFailure { e -> _state.update { it.copy(isSaving = false, error = e.message) } }
+        }
+    }
+
+    private fun buildEntity(s: AddPairUiState, name: String, localPath: String, remotePath: String, id: Long) =
+        SyncPairEntity(
+            id = id,
+            name = name, localPath = localPath, remotePath = remotePath,
             accountId = s.selectedAccountId,
             syncDirection = s.syncDirection, conflictStrategy = s.conflictStrategy,
             deleteBehavior = s.deleteBehavior, recursive = s.recursive,
@@ -150,26 +264,29 @@ 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 {
-                    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)
+
+    /**
+     * 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)
             }
         }
     }
-                .onSuccess {
-                    if (s.scheduleType == ScheduleType.ON_CHANGE) FileWatchService.start(context)
-                    _state.update { it.copy(done = true) }
-                }
-                .onFailure { e -> _state.update { it.copy(isSaving = false, error = e.message) } }
-        }
-    }
 }

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

@@ -0,0 +1,106 @@
+package com.syncflow.domain.sync
+
+import com.syncflow.domain.model.ConflictStrategy
+import com.syncflow.domain.model.DeleteBehavior
+import com.syncflow.domain.model.ScheduleType
+import com.syncflow.domain.model.SyncDirection
+import com.syncflow.domain.model.SyncPair
+import com.syncflow.domain.model.SyncStatus
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Exclusion symmetry: paths excluded from the local walk must also be excluded from the remote
+ * listing and the merged work set, so a previously-uploaded excluded file is never DELETE_REMOTE'd
+ * in an endless churn loop (the ".thumbnails" cache regression).
+ */
+class ExcludePathTest {
+
+    private fun pair(
+        excludePatterns: List<String> = emptyList(),
+        excludeExtensions: List<String> = emptyList(),
+        skipHiddenFiles: Boolean = false,
+    ) = SyncPair(
+        id = 1, name = "t", localPath = "/l", remotePath = "/r", accountId = 1,
+        syncDirection = SyncDirection.TWO_WAY,
+        conflictStrategy = ConflictStrategy.KEEP_NEWEST,
+        deleteBehavior = DeleteBehavior.MIRROR,
+        recursive = true,
+        scheduleType = ScheduleType.MANUAL, scheduleIntervalMinutes = 0,
+        scheduleDailyTime = null, scheduleWeekdays = 0,
+        wifiOnly = false, wifiSsid = "", chargingOnly = false, minBatteryPct = 0,
+        excludePatterns = excludePatterns, includeExtensions = emptyList(),
+        excludeExtensions = excludeExtensions, skipHiddenFiles = skipHiddenFiles,
+        minFileSizeKb = 0, maxFileSizeKb = 0,
+        notifyOnComplete = false, notifyOnError = false,
+        isEnabled = true, lastSyncAt = null, lastSyncResult = SyncStatus.IDLE,
+        pendingConflicts = 0,
+    )
+
+    @Test fun `thumbnails cache is always excluded regardless of config`() {
+        val p = pair()
+        assertTrue(isExcludedPath("DCIM/.thumbnails/123.jpg", p))
+        assertTrue(isExcludedPath("Pictures/.thumbnails/1000020397.jpg", p))
+        assertTrue(isExcludedPath(".thumbnails/x.jpg", p))
+    }
+
+    @Test fun `android trash and pending staging dirs are excluded`() {
+        val p = pair()
+        assertTrue(isExcludedPath("DCIM/Camera/.trashed-1700000000-IMG_0001.jpg", p))
+        assertTrue(isExcludedPath("DCIM/.pending-1700000000-VID_0001.mp4", p))
+    }
+
+    @Test fun `our own atomic-write temp files are excluded`() {
+        val p = pair()
+        assertTrue(isExcludedPath("Download/.movie.mp4.sfpart", p))
+        assertTrue(isExcludedPath("a/b/.photo.jpg.sfpart", p))
+    }
+
+    @Test fun `android app-private trees are excluded (scoped-storage unreadable)`() {
+        val p = pair()
+        assertTrue(isExcludedPath("Android/media/com.whatsapp/WhatsApp/Media/IMG.jpg", p))
+        assertTrue(isExcludedPath("Android/data/com.foo/files/x.bin", p))
+        assertTrue(isExcludedPath("Android/obb/com.game/main.obb", p))
+        assertTrue(isExcludedPath("android/MEDIA/com.x/y.jpg", p)) // case-insensitive
+    }
+
+    @Test fun `non-private Android paths are not excluded`() {
+        val p = pair()
+        // A user folder literally named "Android" at a deeper level is fine; only the
+        // top-level app-private trees are blocked.
+        assertFalse(isExcludedPath("DCIM/Android/holiday.jpg", p))
+        assertFalse(isExcludedPath("Pictures/android-wallpaper.png", p))
+    }
+
+    @Test fun `normal media files are not excluded`() {
+        val p = pair()
+        assertFalse(isExcludedPath("DCIM/Camera/IMG_0001.jpg", p))
+        assertFalse(isExcludedPath("Pictures/cat.png", p))
+        assertFalse(isExcludedPath("اصفهان/20171023.jpg", p)) // unicode folder, real data
+    }
+
+    @Test fun `user exclude patterns and extensions still apply on filename`() {
+        assertTrue(isExcludedPath("a/Thumbs.db", pair(excludePatterns = listOf("Thumbs.db"))))
+        assertTrue(isExcludedPath("a/note.tmp", pair(excludePatterns = listOf("*.tmp"))))
+        assertTrue(isExcludedPath("a/data.log", pair(excludeExtensions = listOf("log"))))
+        assertFalse(isExcludedPath("a/keep.jpg", pair(excludeExtensions = listOf("log"))))
+    }
+
+    @Test fun `skipHiddenFiles excludes dotfiles by filename only`() {
+        assertTrue(isExcludedPath("a/.hidden", pair(skipHiddenFiles = true)))
+        assertFalse(isExcludedPath("a/.hidden", pair(skipHiddenFiles = false)))
+    }
+
+    @Test fun `remote-not-found detected from http status messages`() {
+        assertTrue(isRemoteNotFound(Exception("HTTP 404")))
+        assertTrue(isRemoteNotFound(Exception("Not Found")))
+        assertTrue(isRemoteNotFound(RuntimeException("PROPFIND failed: notfound")))
+    }
+
+    @Test fun `remote-not-found is false for other errors`() {
+        assertFalse(isRemoteNotFound(Exception("HTTP 500")))
+        assertFalse(isRemoteNotFound(Exception("timeout")))
+        assertFalse(isRemoteNotFound(Exception(null as String?)))
+    }
+}

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/MultiFolderTest.kt

@@ -0,0 +1,41 @@
+package com.syncflow.ui.addpair
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+/**
+ * Multi-folder backup: each selected folder maps to its OWN remote subfolder. The leaf-name and
+ * uniqueness helpers are what keep that safe — same-named folders from different parents must not
+ * collapse into one remote dir and overwrite each other.
+ */
+class MultiFolderTest {
+
+    @Test fun `leaf name from SAF tree uri`() {
+        assertEquals("Camera", folderLeafName("content://com.android.externalstorage.documents/tree/primary%3ADCIM%2FCamera"))
+        assertEquals("DCIM", folderLeafName("content://com.android.externalstorage.documents/tree/primary%3ADCIM"))
+    }
+
+    @Test fun `leaf name from plain filesystem path`() {
+        assertEquals("Camera", folderLeafName("/storage/emulated/0/DCIM/Camera"))
+        assertEquals("Pictures", folderLeafName("/storage/emulated/0/Pictures/"))
+    }
+
+    @Test fun `blank-ish paths fall back to folder`() {
+        assertEquals("folder", folderLeafName(""))
+        assertEquals("folder", folderLeafName("/"))
+    }
+
+    @Test fun `unique sub names disambiguate collisions`() {
+        val used = mutableSetOf<String>()
+        assertEquals("Camera", uniqueSubName("Camera", used))
+        assertEquals("Camera_2", uniqueSubName("Camera", used))
+        assertEquals("Camera_3", uniqueSubName("Camera", used))
+        assertEquals("Pictures", uniqueSubName("Pictures", used))
+    }
+
+    @Test fun `unique sub name flattens slashes`() {
+        val used = mutableSetOf<String>()
+        assertTrue('/' !in uniqueSubName("a/b/c", used))
+    }
+}

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))
+}

version.properties

@@ -1,2 +1,2 @@
-VERSION_NAME=1.0.63
-VERSION_CODE=64
+VERSION_NAME=1.0.76
+VERSION_CODE=76