diff --git a/opencloudApp/src/main/AndroidManifest.xml b/opencloudApp/src/main/AndroidManifest.xml
index 93edc6257..6aea0dacd 100644
--- a/opencloudApp/src/main/AndroidManifest.xml
+++ b/opencloudApp/src/main/AndroidManifest.xml
@@ -23,6 +23,7 @@
         API >= 23; the app needs to handle this
     -->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" tools:ignore="ScopedStorage" />
     <!--
         Notifications are off by default since API 33;
         See note in https://developer.android.com/develop/ui/views/notifications/notification-permission
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/presentation/documentsprovider/DocumentsStorageProvider.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/documentsprovider/DocumentsStorageProvider.kt
index 45d8a58f3..37477b471 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/presentation/documentsprovider/DocumentsStorageProvider.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/presentation/documentsprovider/DocumentsStorageProvider.kt
@@ -158,13 +158,9 @@ class DocumentsStorageProvider : DocumentsProvider() {
                                 )
                             )
                             Timber.d("Synced ${ocFile.remotePath} from ${ocFile.owner} with result: $result")
-                            if (result.getDataOrNull() is SynchronizeFileUseCase.SyncType.ConflictDetected) {
-                                context?.let {
-                                    NotificationUtils.notifyConflict(
-                                        fileInConflict = ocFile,
-                                        context = it
-                                    )
-                                }
+                            if (result.getDataOrNull() is SynchronizeFileUseCase.SyncType.ConflictResolvedWithCopy) {
+                                val conflictResult = result.getDataOrNull() as SynchronizeFileUseCase.SyncType.ConflictResolvedWithCopy
+                                Timber.i("File sync conflict auto-resolved. Conflicted copy at: ${conflictResult.conflictedCopyPath}")
                             }
                         }.start()
                     }
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/presentation/files/details/FileDetailsFragment.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/files/details/FileDetailsFragment.kt
index 6aaed24c1..fcc9e71be 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/presentation/files/details/FileDetailsFragment.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/presentation/files/details/FileDetailsFragment.kt
@@ -190,10 +190,8 @@ class FileDetailsFragment : FileFragment() {
                         SynchronizeFileUseCase.SyncType.AlreadySynchronized -> {
                             showMessageInSnackbar(getString(R.string.sync_file_nothing_to_do_msg))
                         }
-                        is SynchronizeFileUseCase.SyncType.ConflictDetected -> {
-                            val showConflictActivityIntent = Intent(requireActivity(), ConflictsResolveActivity::class.java)
-                            showConflictActivityIntent.putExtra(ConflictsResolveActivity.EXTRA_FILE, file)
-                            startActivity(showConflictActivityIntent)
+                        is SynchronizeFileUseCase.SyncType.ConflictResolvedWithCopy -> {
+                            showMessageInSnackbar(getString(R.string.sync_conflict_resolved_with_copy))
                         }
 
                         is SynchronizeFileUseCase.SyncType.DownloadEnqueued -> {
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityFragment.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityFragment.kt
index 5f28b8f7b..5ebe308eb 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityFragment.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityFragment.kt
@@ -42,12 +42,15 @@ import eu.opencloud.android.presentation.security.biometric.BiometricManager
 import eu.opencloud.android.presentation.security.passcode.PassCodeActivity
 import eu.opencloud.android.presentation.security.pattern.PatternActivity
 import eu.opencloud.android.presentation.settings.SettingsFragment.Companion.removePreferenceFromScreen
+import eu.opencloud.android.providers.WorkManagerProvider
+import org.koin.android.ext.android.inject
 import org.koin.androidx.viewmodel.ext.android.viewModel
 
 class SettingsSecurityFragment : PreferenceFragmentCompat() {
 
     // ViewModel
     private val securityViewModel by viewModel<SettingsSecurityViewModel>()
+    private val workManagerProvider: WorkManagerProvider by inject()
 
     private var screenSecurity: PreferenceScreen? = null
     private var prefPasscode: CheckBoxPreference? = null
@@ -56,6 +59,9 @@ class SettingsSecurityFragment : PreferenceFragmentCompat() {
     private var prefLockApplication: ListPreference? = null
     private var prefLockAccessDocumentProvider: CheckBoxPreference? = null
     private var prefTouchesWithOtherVisibleWindows: CheckBoxPreference? = null
+    private var prefDownloadEverything: CheckBoxPreference? = null
+    private var prefAutoSync: CheckBoxPreference? = null
+    private var prefPreferLocalOnConflict: CheckBoxPreference? = null
 
     private val enablePasscodeLauncher =
         registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
@@ -132,6 +138,9 @@ class SettingsSecurityFragment : PreferenceFragmentCompat() {
         }
         prefLockAccessDocumentProvider = findPreference(PREFERENCE_LOCK_ACCESS_FROM_DOCUMENT_PROVIDER)
         prefTouchesWithOtherVisibleWindows = findPreference(PREFERENCE_TOUCHES_WITH_OTHER_VISIBLE_WINDOWS)
+        prefDownloadEverything = findPreference(PREFERENCE_DOWNLOAD_EVERYTHING)
+        prefAutoSync = findPreference(PREFERENCE_AUTO_SYNC)
+        prefPreferLocalOnConflict = findPreference(PREFERENCE_PREFER_LOCAL_ON_CONFLICT)
 
         prefPasscode?.isVisible = !securityViewModel.isSecurityEnforcedEnabled()
         prefPattern?.isVisible = !securityViewModel.isSecurityEnforcedEnabled()
@@ -222,6 +231,60 @@ class SettingsSecurityFragment : PreferenceFragmentCompat() {
             }
             true
         }
+
+        // Download Everything Feature
+        prefDownloadEverything?.setOnPreferenceChangeListener { _: Preference?, newValue: Any ->
+            if (newValue as Boolean) {
+                activity?.let {
+                    AlertDialog.Builder(it)
+                        .setTitle(getString(R.string.download_everything_warning_title))
+                        .setMessage(getString(R.string.download_everything_warning_message))
+                        .setNegativeButton(getString(R.string.common_no), null)
+                        .setPositiveButton(getString(R.string.common_yes)) { _, _ ->
+                            securityViewModel.setDownloadEverything(true)
+                            prefDownloadEverything?.isChecked = true
+                            workManagerProvider.enqueueDownloadEverythingWorker()
+                        }
+                        .show()
+                        .avoidScreenshotsIfNeeded()
+                }
+                return@setOnPreferenceChangeListener false
+            } else {
+                securityViewModel.setDownloadEverything(false)
+                workManagerProvider.cancelDownloadEverythingWorker()
+                true
+            }
+        }
+
+        // Auto-Sync Feature
+        prefAutoSync?.setOnPreferenceChangeListener { _: Preference?, newValue: Any ->
+            if (newValue as Boolean) {
+                activity?.let {
+                    AlertDialog.Builder(it)
+                        .setTitle(getString(R.string.auto_sync_warning_title))
+                        .setMessage(getString(R.string.auto_sync_warning_message))
+                        .setNegativeButton(getString(R.string.common_no), null)
+                        .setPositiveButton(getString(R.string.common_yes)) { _, _ ->
+                            securityViewModel.setAutoSync(true)
+                            prefAutoSync?.isChecked = true
+                            workManagerProvider.enqueueLocalFileSyncWorker()
+                        }
+                        .show()
+                        .avoidScreenshotsIfNeeded()
+                }
+                return@setOnPreferenceChangeListener false
+            } else {
+                securityViewModel.setAutoSync(false)
+                workManagerProvider.cancelLocalFileSyncWorker()
+                true
+            }
+        }
+
+        // Conflict Resolution Strategy
+        prefPreferLocalOnConflict?.setOnPreferenceChangeListener { _: Preference?, newValue: Any ->
+            securityViewModel.setPreferLocalOnConflict(newValue as Boolean)
+            true
+        }
     }
 
     private fun enableBiometricAndLockApplication() {
@@ -246,5 +309,8 @@ class SettingsSecurityFragment : PreferenceFragmentCompat() {
         const val PREFERENCE_TOUCHES_WITH_OTHER_VISIBLE_WINDOWS = "touches_with_other_visible_windows"
         const val EXTRAS_LOCK_ENFORCED = "EXTRAS_LOCK_ENFORCED"
         const val PREFERENCE_LOCK_ATTEMPTS = "PrefLockAttempts"
+        const val PREFERENCE_DOWNLOAD_EVERYTHING = "download_everything"
+        const val PREFERENCE_AUTO_SYNC = "auto_sync_local_changes"
+        const val PREFERENCE_PREFER_LOCAL_ON_CONFLICT = "prefer_local_on_conflict"
     }
 }
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityViewModel.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityViewModel.kt
index 103cd4e5c..c179eb94c 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityViewModel.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/security/SettingsSecurityViewModel.kt
@@ -63,4 +63,25 @@ class SettingsSecurityViewModel(
             integerKey = R.integer.lock_delay_enforced
         )
     ) != LockTimeout.DISABLED
+
+    // Download Everything Feature
+    fun isDownloadEverythingEnabled(): Boolean =
+        preferencesProvider.getBoolean(SettingsSecurityFragment.PREFERENCE_DOWNLOAD_EVERYTHING, false)
+
+    fun setDownloadEverything(enabled: Boolean) =
+        preferencesProvider.putBoolean(SettingsSecurityFragment.PREFERENCE_DOWNLOAD_EVERYTHING, enabled)
+
+    // Auto-Sync Feature
+    fun isAutoSyncEnabled(): Boolean =
+        preferencesProvider.getBoolean(SettingsSecurityFragment.PREFERENCE_AUTO_SYNC, false)
+
+    fun setAutoSync(enabled: Boolean) =
+        preferencesProvider.putBoolean(SettingsSecurityFragment.PREFERENCE_AUTO_SYNC, enabled)
+
+    // Conflict Resolution Strategy
+    fun isPreferLocalOnConflictEnabled(): Boolean =
+        preferencesProvider.getBoolean(SettingsSecurityFragment.PREFERENCE_PREFER_LOCAL_ON_CONFLICT, false)
+
+    fun setPreferLocalOnConflict(enabled: Boolean) =
+        preferencesProvider.putBoolean(SettingsSecurityFragment.PREFERENCE_PREFER_LOCAL_ON_CONFLICT, enabled)
 }
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/providers/WorkManagerProvider.kt b/opencloudApp/src/main/java/eu/opencloud/android/providers/WorkManagerProvider.kt
index 4d538eb76..09d9e6b86 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/providers/WorkManagerProvider.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/providers/WorkManagerProvider.kt
@@ -36,6 +36,8 @@ import eu.opencloud.android.workers.AccountDiscoveryWorker
 import eu.opencloud.android.workers.AvailableOfflinePeriodicWorker
 import eu.opencloud.android.workers.AvailableOfflinePeriodicWorker.Companion.AVAILABLE_OFFLINE_PERIODIC_WORKER
 import eu.opencloud.android.workers.AutomaticUploadsWorker
+import eu.opencloud.android.workers.DownloadEverythingWorker
+import eu.opencloud.android.workers.LocalFileSyncWorker
 import eu.opencloud.android.workers.OldLogsCollectorWorker
 import eu.opencloud.android.workers.RemoveLocallyFilesWithLastUsageOlderThanGivenTimeWorker
 import eu.opencloud.android.workers.UploadFileFromContentUriWorker
@@ -129,4 +131,60 @@ class WorkManagerProvider(
 
     fun cancelAllWorkByTag(tag: String) = WorkManager.getInstance(context).cancelAllWorkByTag(tag)
 
+    // Download Everything Feature
+    fun enqueueDownloadEverythingWorker() {
+        val constraintsRequired = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .setRequiresBatteryNotLow(true)
+            .setRequiresStorageNotLow(true)
+            .build()
+
+        val downloadEverythingWorker = PeriodicWorkRequestBuilder<DownloadEverythingWorker>(
+            repeatInterval = DownloadEverythingWorker.repeatInterval,
+            repeatIntervalTimeUnit = DownloadEverythingWorker.repeatIntervalTimeUnit
+        )
+            .addTag(DownloadEverythingWorker.DOWNLOAD_EVERYTHING_WORKER)
+            .setConstraints(constraintsRequired)
+            .build()
+
+        WorkManager.getInstance(context)
+            .enqueueUniquePeriodicWork(
+                DownloadEverythingWorker.DOWNLOAD_EVERYTHING_WORKER,
+                ExistingPeriodicWorkPolicy.KEEP,
+                downloadEverythingWorker
+            )
+    }
+
+    fun cancelDownloadEverythingWorker() {
+        WorkManager.getInstance(context)
+            .cancelUniqueWork(DownloadEverythingWorker.DOWNLOAD_EVERYTHING_WORKER)
+    }
+
+    // Local File Sync (Auto-Sync) Feature
+    fun enqueueLocalFileSyncWorker() {
+        val constraintsRequired = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+
+        val localFileSyncWorker = PeriodicWorkRequestBuilder<LocalFileSyncWorker>(
+            repeatInterval = LocalFileSyncWorker.repeatInterval,
+            repeatIntervalTimeUnit = LocalFileSyncWorker.repeatIntervalTimeUnit
+        )
+            .addTag(LocalFileSyncWorker.LOCAL_FILE_SYNC_WORKER)
+            .setConstraints(constraintsRequired)
+            .build()
+
+        WorkManager.getInstance(context)
+            .enqueueUniquePeriodicWork(
+                LocalFileSyncWorker.LOCAL_FILE_SYNC_WORKER,
+                ExistingPeriodicWorkPolicy.KEEP,
+                localFileSyncWorker
+            )
+    }
+
+    fun cancelLocalFileSyncWorker() {
+        WorkManager.getInstance(context)
+            .cancelUniqueWork(LocalFileSyncWorker.LOCAL_FILE_SYNC_WORKER)
+    }
+
 }
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/ui/activity/FileDisplayActivity.kt b/opencloudApp/src/main/java/eu/opencloud/android/ui/activity/FileDisplayActivity.kt
index 97508d873..b2dfd5706 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/ui/activity/FileDisplayActivity.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/ui/activity/FileDisplayActivity.kt
@@ -110,6 +110,7 @@ import eu.opencloud.android.presentation.spaces.SpacesListFragment.Companion.BUN
 import eu.opencloud.android.presentation.spaces.SpacesListFragment.Companion.REQUEST_KEY_CLICK_SPACE
 import eu.opencloud.android.presentation.spaces.SpacesListViewModel
 import eu.opencloud.android.presentation.transfers.TransfersViewModel
+import eu.opencloud.android.presentation.settings.security.SettingsSecurityFragment
 import eu.opencloud.android.providers.WorkManagerProvider
 import eu.opencloud.android.syncadapter.FileSyncAdapter
 import eu.opencloud.android.ui.dialog.FileAlreadyExistsDialog
@@ -284,9 +285,28 @@ class FileDisplayActivity : FileActivity(),
 
 
         checkNotificationPermission()
+        checkManageExternalStoragePermission()
         Timber.v("onCreate() end")
     }
 
+    private fun checkManageExternalStoragePermission() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            if (!android.os.Environment.isExternalStorageManager()) {
+                val builder = AlertDialog.Builder(this)
+                builder.setTitle(getString(R.string.app_name))
+                builder.setMessage("To save offline files, the app needs access to all files.")
+                builder.setPositiveButton("Settings") { _, _ ->
+                    val intent = Intent(android.provider.Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION)
+                    intent.addCategory("android.intent.category.DEFAULT")
+                    intent.data = Uri.parse("package:$packageName")
+                    startActivity(intent)
+                }
+                builder.setNegativeButton("Cancel", null)
+                builder.show()
+            }
+        }
+    }
+
     private fun checkNotificationPermission() {
         // Ask for permission only in case it's api >= 33 and notifications are not granted.
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
@@ -376,6 +396,16 @@ class FileDisplayActivity : FileActivity(),
                 syncProfileOperation.syncUserProfile()
                 val workManagerProvider = WorkManagerProvider(context = baseContext)
                 workManagerProvider.enqueueAvailableOfflinePeriodicWorker()
+                
+                // Enqueue Download Everything worker if enabled
+                if (sharedPreferences.getBoolean(SettingsSecurityFragment.PREFERENCE_DOWNLOAD_EVERYTHING, false)) {
+                    workManagerProvider.enqueueDownloadEverythingWorker()
+                }
+                
+                // Enqueue Local File Sync worker if enabled
+                if (sharedPreferences.getBoolean(SettingsSecurityFragment.PREFERENCE_AUTO_SYNC, false)) {
+                    workManagerProvider.enqueueLocalFileSyncWorker()
+                }
             } else {
                 file?.isFolder?.let { isFolder ->
                     updateFragmentsVisibility(!isFolder)
@@ -1354,10 +1384,8 @@ class FileDisplayActivity : FileActivity(),
                         }
                     }
 
-                    is SynchronizeFileUseCase.SyncType.ConflictDetected -> {
-                        val showConflictActivityIntent = Intent(this, ConflictsResolveActivity::class.java)
-                        showConflictActivityIntent.putExtra(ConflictsResolveActivity.EXTRA_FILE, file)
-                        startActivity(showConflictActivityIntent)
+                    is SynchronizeFileUseCase.SyncType.ConflictResolvedWithCopy -> {
+                        showSnackMessage(getString(R.string.sync_conflict_resolved_with_copy))
                     }
 
                     is SynchronizeFileUseCase.SyncType.DownloadEnqueued -> {
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/usecases/synchronization/SynchronizeFileUseCase.kt b/opencloudApp/src/main/java/eu/opencloud/android/usecases/synchronization/SynchronizeFileUseCase.kt
index f75824b29..ef147cab7 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/usecases/synchronization/SynchronizeFileUseCase.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/usecases/synchronization/SynchronizeFileUseCase.kt
@@ -21,16 +21,22 @@
 
 package eu.opencloud.android.usecases.synchronization
 
+import eu.opencloud.android.data.providers.SharedPreferencesProvider
 import eu.opencloud.android.domain.BaseUseCaseWithResult
 import eu.opencloud.android.domain.exceptions.FileNotFoundException
 import eu.opencloud.android.domain.files.FileRepository
 import eu.opencloud.android.domain.files.model.OCFile
 import eu.opencloud.android.domain.files.usecases.SaveConflictUseCase
+import eu.opencloud.android.presentation.settings.security.SettingsSecurityFragment
 import eu.opencloud.android.usecases.transfers.downloads.DownloadFileUseCase
 import eu.opencloud.android.usecases.transfers.uploads.UploadFileInConflictUseCase
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import timber.log.Timber
+import java.io.File
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
 import java.util.UUID
 
 class SynchronizeFileUseCase(
@@ -38,6 +44,7 @@ class SynchronizeFileUseCase(
     private val uploadFileInConflictUseCase: UploadFileInConflictUseCase,
     private val saveConflictUseCase: SaveConflictUseCase,
     private val fileRepository: FileRepository,
+    private val preferencesProvider: SharedPreferencesProvider,
 ) : BaseUseCaseWithResult<SynchronizeFileUseCase.SyncType, SynchronizeFileUseCase.Params>() {
 
     override fun run(params: Params): SyncType {
@@ -71,9 +78,11 @@ class SynchronizeFileUseCase(
                 val uuid = requestForDownload(accountName = accountName, ocFile = fileToSynchronize)
                 SyncType.DownloadEnqueued(uuid)
             } else {
-                // 3. Check if file has changed locally
-                val changedLocally = fileToSynchronize.localModificationTimestamp > fileToSynchronize.lastSyncDateForData!!
-                Timber.i("Local file modification timestamp :${fileToSynchronize.localModificationTimestamp}" +
+                // 3. Check if file has changed locally by reading ACTUAL file timestamp from filesystem
+                val localFile = File(fileToSynchronize.storagePath!!)
+                val actualFileModificationTime = localFile.lastModified()
+                val changedLocally = actualFileModificationTime > fileToSynchronize.lastSyncDateForData!!
+                Timber.i("Actual file modification timestamp :$actualFileModificationTime" +
                         " and last sync date for data :${fileToSynchronize.lastSyncDateForData}")
                 Timber.i("So it has changed locally: $changedLocally")
 
@@ -83,17 +92,43 @@ class SynchronizeFileUseCase(
                 Timber.i("So it has changed remotely: $changedRemotely")
 
                 if (changedLocally && changedRemotely) {
-                    // 5.1 File has changed locally and remotely. We got a conflict, save the conflict.
-                    Timber.i("File ${fileToSynchronize.fileName} has changed locally and remotely. We got a conflict with etag: ${serverFile.etag}")
-                    if (fileToSynchronize.etagInConflict == null) {
-                        saveConflictUseCase(
-                            SaveConflictUseCase.Params(
-                                fileId = fileToSynchronize.id!!,
-                                eTagInConflict = serverFile.etag!!
-                            )
-                        )
+                    // 5.1 File has changed locally and remotely.
+                    val preferLocal = preferencesProvider.getBoolean(
+                        SettingsSecurityFragment.PREFERENCE_PREFER_LOCAL_ON_CONFLICT, false
+                    )
+                    
+                    if (preferLocal) {
+                        // User prefers local version - upload it (overwrites remote)
+                        Timber.i("File ${fileToSynchronize.fileName} has conflict. User prefers local version, uploading.")
+                        val uuid = requestForUpload(accountName, fileToSynchronize)
+                        SyncType.UploadEnqueued(uuid)
+                    } else {
+                        // Default: Create conflicted copy of local, download remote.
+                        Timber.i("File ${fileToSynchronize.fileName} has changed locally and remotely. Creating conflicted copy.")
+                        val conflictedCopyPath = createConflictedCopyPath(fileToSynchronize)
+                        val renamed = renameLocalFile(fileToSynchronize.storagePath!!, conflictedCopyPath)
+                        if (renamed) {
+                            Timber.i("Local file renamed to conflicted copy: $conflictedCopyPath")
+                            // Refresh parent folder so the conflicted copy appears in the file list
+                            try {
+                                fileRepository.refreshFolder(
+                                    remotePath = fileToSynchronize.getParentRemotePath(),
+                                    accountName = accountName,
+                                    spaceId = fileToSynchronize.spaceId
+                                )
+                                Timber.i("Parent folder refreshed after creating conflicted copy")
+                            } catch (e: Exception) {
+                                Timber.w(e, "Failed to refresh parent folder after creating conflicted copy")
+                            }
+                            val uuid = requestForDownload(accountName, fileToSynchronize)
+                            SyncType.ConflictResolvedWithCopy(uuid, conflictedCopyPath)
+                        } else {
+                            Timber.w("Failed to rename local file to conflicted copy")
+                            // Fallback: download remote anyway, local changes may be overwritten
+                            val uuid = requestForDownload(accountName, fileToSynchronize)
+                            SyncType.DownloadEnqueued(uuid)
+                        }
                     }
-                    SyncType.ConflictDetected(serverFile.etag!!)
                 } else if (changedRemotely) {
                     // 5.2 File has changed ONLY remotely -> download new version
                     Timber.i("File ${fileToSynchronize.fileName} has changed remotely. Let's download the new version")
@@ -131,13 +166,36 @@ class SynchronizeFileUseCase(
             )
         )
 
+    private fun createConflictedCopyPath(ocFile: OCFile): String {
+        val originalPath = ocFile.storagePath!!
+        val file = File(originalPath)
+        val nameWithoutExt = file.nameWithoutExtension
+        val extension = file.extension
+        val timestamp = SimpleDateFormat("yyyy-MM-dd_HHmmss", Locale.US).format(Date())
+        val conflictedName = if (extension.isNotEmpty()) {
+            "${nameWithoutExt}_conflicted_copy_$timestamp.$extension"
+        } else {
+            "${nameWithoutExt}_conflicted_copy_$timestamp"
+        }
+        return File(file.parent, conflictedName).absolutePath
+    }
+
+    private fun renameLocalFile(oldPath: String, newPath: String): Boolean {
+        return try {
+            File(oldPath).renameTo(File(newPath))
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to rename local file from $oldPath to $newPath")
+            false
+        }
+    }
+
     data class Params(
         val fileToSynchronize: OCFile,
     )
 
     sealed interface SyncType {
         object FileNotFound : SyncType
-        data class ConflictDetected(val etagInConflict: String) : SyncType
+        data class ConflictResolvedWithCopy(val workerId: UUID?, val conflictedCopyPath: String) : SyncType
         data class DownloadEnqueued(val workerId: UUID?) : SyncType
         data class UploadEnqueued(val workerId: UUID?) : SyncType
         object AlreadySynchronized : SyncType
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/workers/DownloadEverythingWorker.kt b/opencloudApp/src/main/java/eu/opencloud/android/workers/DownloadEverythingWorker.kt
new file mode 100644
index 000000000..20f79be9e
--- /dev/null
+++ b/opencloudApp/src/main/java/eu/opencloud/android/workers/DownloadEverythingWorker.kt
@@ -0,0 +1,300 @@
+/**
+ * openCloud Android client application
+ *
+ * @author OpenCloud Development Team
+ *
+ * Copyright (C) 2026 OpenCloud.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package eu.opencloud.android.workers
+
+import android.accounts.AccountManager
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.work.CoroutineWorker
+import androidx.work.WorkerParameters
+import eu.opencloud.android.MainApp
+import eu.opencloud.android.R
+import eu.opencloud.android.domain.capabilities.usecases.GetStoredCapabilitiesUseCase
+import eu.opencloud.android.domain.files.FileRepository
+import eu.opencloud.android.domain.files.model.OCFile
+import eu.opencloud.android.domain.files.model.OCFile.Companion.ROOT_PATH
+import eu.opencloud.android.domain.files.usecases.GetFileByRemotePathUseCase
+import eu.opencloud.android.domain.spaces.usecases.GetPersonalAndProjectSpacesForAccountUseCase
+import eu.opencloud.android.domain.spaces.usecases.RefreshSpacesFromServerAsyncUseCase
+import eu.opencloud.android.presentation.authentication.AccountUtils
+import eu.opencloud.android.usecases.transfers.downloads.DownloadFileUseCase
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import timber.log.Timber
+import java.util.concurrent.TimeUnit
+
+/**
+ * Worker that downloads ALL files from all accounts for offline access.
+ * This is an opt-in feature that can be enabled in Security Settings.
+ * 
+ * This worker:
+ * 1. Iterates through all connected accounts
+ * 2. Discovers all spaces (personal + project) for each account
+ * 3. Recursively scans all folders to find all files
+ * 4. Enqueues a download for each file that is not yet available locally
+ * 5. Shows a notification with progress information
+ */
+class DownloadEverythingWorker(
+    private val appContext: Context,
+    workerParameters: WorkerParameters
+) : CoroutineWorker(
+    appContext,
+    workerParameters
+), KoinComponent {
+
+    private val getStoredCapabilitiesUseCase: GetStoredCapabilitiesUseCase by inject()
+    private val refreshSpacesFromServerAsyncUseCase: RefreshSpacesFromServerAsyncUseCase by inject()
+    private val getPersonalAndProjectSpacesForAccountUseCase: GetPersonalAndProjectSpacesForAccountUseCase by inject()
+    private val getFileByRemotePathUseCase: GetFileByRemotePathUseCase by inject()
+    private val fileRepository: FileRepository by inject()
+    private val downloadFileUseCase: DownloadFileUseCase by inject()
+
+    private var totalFilesFound = 0
+    private var filesDownloaded = 0
+    private var filesAlreadyLocal = 0
+    private var filesSkipped = 0
+    private var foldersProcessed = 0
+
+    override suspend fun doWork(): Result {
+        Timber.i("DownloadEverythingWorker started")
+        
+        // Create notification channel and show initial notification
+        createNotificationChannel()
+        updateNotification("Starting download of all files...")
+
+        return try {
+            val accountManager = AccountManager.get(appContext)
+            val accounts = accountManager.getAccountsByType(MainApp.accountType)
+
+            Timber.i("Found ${accounts.size} accounts to process")
+            updateNotification("Found ${accounts.size} accounts")
+
+            accounts.forEachIndexed { accountIndex, account ->
+                val accountName = account.name
+                Timber.i("Processing account ${accountIndex + 1}/${accounts.size}: $accountName")
+                updateNotification("Account ${accountIndex + 1}/${accounts.size}: $accountName")
+
+                try {
+                    // Get capabilities for account
+                    val capabilities = getStoredCapabilitiesUseCase(GetStoredCapabilitiesUseCase.Params(accountName))
+                    val spacesAvailableForAccount = AccountUtils.isSpacesFeatureAllowedForAccount(appContext, account, capabilities)
+
+                    if (!spacesAvailableForAccount) {
+                        // Account does not support spaces - process legacy root
+                        Timber.i("Account $accountName uses legacy mode (no spaces)")
+                        processSpaceRoot(accountName, ROOT_PATH, null)
+                    } else {
+                        // Account supports spaces - process all spaces
+                        refreshSpacesFromServerAsyncUseCase(RefreshSpacesFromServerAsyncUseCase.Params(accountName))
+                        val spaces = getPersonalAndProjectSpacesForAccountUseCase(
+                            GetPersonalAndProjectSpacesForAccountUseCase.Params(accountName)
+                        )
+
+                        Timber.i("Account $accountName has ${spaces.size} spaces")
+
+                        spaces.forEachIndexed { spaceIndex, space ->
+                            Timber.i("Processing space ${spaceIndex + 1}/${spaces.size}: ${space.name}")
+                            updateNotification("Space ${spaceIndex + 1}/${spaces.size}: ${space.name}")
+                            
+                            processSpaceRoot(accountName, ROOT_PATH, space.root.id)
+                        }
+                    }
+                } catch (e: Exception) {
+                    Timber.e(e, "Error processing account $accountName")
+                }
+            }
+
+            val summary = "Done! Files: $totalFilesFound, Downloaded: $filesDownloaded, Already local: $filesAlreadyLocal, Skipped: $filesSkipped, Folders: $foldersProcessed"
+            Timber.i("DownloadEverythingWorker completed: $summary")
+            updateNotification(summary)
+
+            Result.success()
+        } catch (exception: Exception) {
+            Timber.e(exception, "DownloadEverythingWorker failed")
+            updateNotification("Failed: ${exception.message}")
+            Result.failure()
+        }
+    }
+
+    /**
+     * Processes the root of a space by refreshing it and then recursively processing all content.
+     */
+    private fun processSpaceRoot(accountName: String, remotePath: String, spaceId: String?) {
+        try {
+            Timber.i("Processing space root: remotePath=$remotePath, spaceId=$spaceId")
+            
+            // First refresh the root folder from server to ensure DB has latest data
+            fileRepository.refreshFolder(
+                remotePath = remotePath,
+                accountName = accountName,
+                spaceId = spaceId,
+                isActionSetFolderAvailableOfflineOrSynchronize = false
+            )
+            
+            // Now get the root folder from local database
+            val rootFolder = getFileByRemotePathUseCase(
+                GetFileByRemotePathUseCase.Params(accountName, remotePath, spaceId)
+            ).getDataOrNull()
+            
+            if (rootFolder == null) {
+                Timber.w("Root folder not found after refresh for spaceId=$spaceId")
+                return
+            }
+            
+            Timber.i("Got root folder with id=${rootFolder.id}, remotePath=${rootFolder.remotePath}")
+            
+            // Process the root folder recursively
+            processFolderRecursively(accountName, rootFolder, spaceId)
+            
+        } catch (e: Exception) {
+            Timber.e(e, "Error processing space root: spaceId=$spaceId")
+        }
+    }
+
+    /**
+     * Recursively processes a folder: gets content from database,
+     * enqueues downloads for files, and recurses into subfolders.
+     */
+    private fun processFolderRecursively(accountName: String, folder: OCFile, spaceId: String?) {
+        try {
+            val folderId = folder.id
+            if (folderId == null) {
+                Timber.w("Folder ${folder.remotePath} has no id, skipping")
+                return
+            }
+            
+            foldersProcessed++
+            Timber.d("Processing folder: ${folder.remotePath} (id=$folderId)")
+            
+            // First refresh this folder from server
+            try {
+                fileRepository.refreshFolder(
+                    remotePath = folder.remotePath,
+                    accountName = accountName,
+                    spaceId = spaceId,
+                    isActionSetFolderAvailableOfflineOrSynchronize = false
+                )
+            } catch (e: Exception) {
+                Timber.e(e, "Error refreshing folder ${folder.remotePath}")
+            }
+            
+            // Now get ALL content from local database (this returns everything, not just changes)
+            val folderContent = fileRepository.getFolderContent(folderId)
+            
+            Timber.d("Folder ${folder.remotePath} contains ${folderContent.size} items")
+
+            folderContent.forEach { item ->
+                if (item.isFolder) {
+                    // Recursively process subfolders
+                    processFolderRecursively(accountName, item, spaceId)
+                } else {
+                    // Process file
+                    processFile(accountName, item)
+                }
+            }
+            
+            // Update notification periodically
+            if (foldersProcessed % 5 == 0) {
+                updateNotification("Scanning: $foldersProcessed folders, $totalFilesFound files found")
+            }
+        } catch (e: Exception) {
+            Timber.e(e, "Error processing folder ${folder.remotePath}")
+        }
+    }
+
+    /**
+     * Processes a single file: checks if it's already local,
+     * and if not, enqueues a download.
+     */
+    private fun processFile(accountName: String, file: OCFile) {
+        totalFilesFound++
+        
+        try {
+            if (file.isAvailableLocally) {
+                // File is already downloaded
+                filesAlreadyLocal++
+                Timber.d("File already local: ${file.fileName}")
+            } else {
+                // Enqueue download
+                val downloadId = downloadFileUseCase(DownloadFileUseCase.Params(accountName, file))
+                if (downloadId != null) {
+                    filesDownloaded++
+                    Timber.i("Enqueued download for: ${file.fileName}")
+                } else {
+                    filesSkipped++
+                    Timber.d("Download already enqueued or skipped: ${file.fileName}")
+                }
+            }
+            
+            // Update notification periodically (every 20 files)
+            if (totalFilesFound % 20 == 0) {
+                updateNotification("Found: $totalFilesFound files, $filesDownloaded queued for download")
+            }
+        } catch (e: Exception) {
+            filesSkipped++
+            Timber.e(e, "Error processing file ${file.fileName}")
+        }
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                NOTIFICATION_CHANNEL_ID,
+                "Download Everything",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Shows progress when downloading all files"
+            }
+            val notificationManager = appContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun updateNotification(contentText: String) {
+        try {
+            val notificationManager = appContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            val notification = NotificationCompat.Builder(appContext, NOTIFICATION_CHANNEL_ID)
+                .setContentTitle("Download Everything")
+                .setContentText(contentText)
+                .setStyle(NotificationCompat.BigTextStyle().bigText(contentText))
+                .setSmallIcon(R.drawable.notification_icon)
+                .setOngoing(true)
+                .setProgress(0, 0, true)
+                .build()
+
+            notificationManager.notify(NOTIFICATION_ID, notification)
+        } catch (e: Exception) {
+            Timber.e(e, "Error updating notification")
+        }
+    }
+
+    companion object {
+        const val DOWNLOAD_EVERYTHING_WORKER = "DOWNLOAD_EVERYTHING_WORKER"
+        const val repeatInterval: Long = 6L
+        val repeatIntervalTimeUnit: TimeUnit = TimeUnit.HOURS
+        
+        private const val NOTIFICATION_CHANNEL_ID = "download_everything_channel"
+        private const val NOTIFICATION_ID = 9001
+    }
+}
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/workers/DownloadFileWorker.kt b/opencloudApp/src/main/java/eu/opencloud/android/workers/DownloadFileWorker.kt
index f5b0e0258..6fa61d69a 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/workers/DownloadFileWorker.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/workers/DownloadFileWorker.kt
@@ -42,6 +42,7 @@ import eu.opencloud.android.domain.files.usecases.GetFileByIdUseCase
 import eu.opencloud.android.domain.files.usecases.GetWebDavUrlForSpaceUseCase
 import eu.opencloud.android.domain.files.usecases.SaveDownloadWorkerUUIDUseCase
 import eu.opencloud.android.domain.files.usecases.SaveFileOrFolderUseCase
+import eu.opencloud.android.domain.spaces.usecases.GetSpaceByIdForAccountUseCase
 import eu.opencloud.android.lib.common.OpenCloudAccount
 import eu.opencloud.android.lib.common.OpenCloudClient
 import eu.opencloud.android.lib.common.SingleSessionManager
@@ -82,9 +83,11 @@ class DownloadFileWorker(
     private val saveDownloadWorkerUuidUseCase: SaveDownloadWorkerUUIDUseCase by inject()
     private val cleanWorkersUuidUseCase: CleanWorkersUUIDUseCase by inject()
     private val localStorageProvider: LocalStorageProvider by inject()
+    private val getSpaceByIdForAccountUseCase: GetSpaceByIdForAccountUseCase by inject()
 
     lateinit var account: Account
     lateinit var ocFile: OCFile
+    private var spaceName: String? = null
 
     private lateinit var downloadRemoteFileOperation: DownloadRemoteFileOperation
     private var lastPercent = 0
@@ -109,7 +112,7 @@ class DownloadFileWorker(
      */
     private val finalLocationForFile: String
         get() = ocFile.storagePath.takeUnless { it.isNullOrBlank() }
-            ?: localStorageProvider.getDefaultSavePathFor(accountName = account.name, remotePath = ocFile.remotePath, spaceId = ocFile.spaceId)
+            ?: localStorageProvider.getDefaultSavePathFor(accountName = account.name, remotePath = ocFile.remotePath, spaceId = ocFile.spaceId, spaceName = spaceName)
 
     override suspend fun doWork(): Result {
         if (!areParametersValid()) return Result.failure()
@@ -140,6 +143,13 @@ class DownloadFileWorker(
         account = AccountUtils.getOpenCloudAccountByName(appContext, accountName) ?: return false
         ocFile = getFileByIdUseCase(GetFileByIdUseCase.Params(fileId)).getDataOrNull() ?: return false
 
+        if (ocFile.spaceId != null) {
+            val space = getSpaceByIdForAccountUseCase(GetSpaceByIdForAccountUseCase.Params(account.name, ocFile.spaceId))
+            if (space != null) {
+                spaceName = space.name
+            }
+        }
+
         return !ocFile.isFolder
     }
 
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/workers/LocalFileSyncWorker.kt b/opencloudApp/src/main/java/eu/opencloud/android/workers/LocalFileSyncWorker.kt
new file mode 100644
index 000000000..284d920a6
--- /dev/null
+++ b/opencloudApp/src/main/java/eu/opencloud/android/workers/LocalFileSyncWorker.kt
@@ -0,0 +1,192 @@
+/**
+ * openCloud Android client application
+ *
+ * @author OpenCloud Development Team
+ *
+ * Copyright (C) 2026 OpenCloud.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package eu.opencloud.android.workers
+
+import android.accounts.AccountManager
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.work.CoroutineWorker
+import androidx.work.ForegroundInfo
+import androidx.work.WorkerParameters
+import eu.opencloud.android.MainApp
+import eu.opencloud.android.R
+import eu.opencloud.android.domain.UseCaseResult
+import eu.opencloud.android.domain.files.FileRepository
+import eu.opencloud.android.usecases.synchronization.SynchronizeFileUseCase
+import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import timber.log.Timber
+import java.util.concurrent.TimeUnit
+
+/**
+ * Worker that periodically syncs locally modified files to the cloud.
+ * This is an opt-in feature that can be enabled in Security Settings.
+ * 
+ * It monitors all downloaded files and checks if they have been modified locally.
+ * If a file has been modified, it uploads the new version to the server.
+ * 
+ * Shows a notification with sync progress and results.
+ */
+class LocalFileSyncWorker(
+    private val appContext: Context,
+    workerParameters: WorkerParameters
+) : CoroutineWorker(
+    appContext,
+    workerParameters
+), KoinComponent {
+
+    private val fileRepository: FileRepository by inject()
+    private val synchronizeFileUseCase: SynchronizeFileUseCase by inject()
+
+    override suspend fun doWork(): Result {
+        Timber.i("LocalFileSyncWorker started")
+        
+        createNotificationChannel()
+
+        return try {
+            val accountManager = AccountManager.get(appContext)
+            val accounts = accountManager.getAccountsByType(MainApp.accountType)
+
+            Timber.i("Checking ${accounts.size} accounts for local file changes")
+
+            var totalFilesChecked = 0
+            var filesUploaded = 0
+            var filesDownloaded = 0
+            var filesWithConflicts = 0
+            var filesAlreadySynced = 0
+            var filesNotFound = 0
+            var errors = 0
+
+            accounts.forEach { account ->
+                val accountName = account.name
+                Timber.d("Checking locally downloaded files for account: $accountName")
+
+                // Get all downloaded files for this account
+                val downloadedFiles = fileRepository.getDownloadedFilesForAccount(accountName)
+                Timber.d("Found ${downloadedFiles.size} downloaded files for account $accountName")
+
+                downloadedFiles.forEach { file ->
+                    if (!file.isFolder) {
+                        totalFilesChecked++
+                        try {
+                            val useCaseResult = synchronizeFileUseCase(SynchronizeFileUseCase.Params(file))
+                            when (useCaseResult) {
+                                is UseCaseResult.Success -> {
+                                    when (val syncResult = useCaseResult.data) {
+                                        is SynchronizeFileUseCase.SyncType.UploadEnqueued -> {
+                                            Timber.i("File ${file.fileName} has local changes, upload enqueued")
+                                            filesUploaded++
+                                        }
+                                        is SynchronizeFileUseCase.SyncType.DownloadEnqueued -> {
+                                            Timber.i("File ${file.fileName} has remote changes, download enqueued")
+                                            filesDownloaded++
+                                        }
+                                        is SynchronizeFileUseCase.SyncType.ConflictResolvedWithCopy -> {
+                                            Timber.i("File ${file.fileName} had a conflict. Conflicted copy created at: ${syncResult.conflictedCopyPath}")
+                                            filesWithConflicts++
+                                        }
+                                        is SynchronizeFileUseCase.SyncType.AlreadySynchronized -> {
+                                            Timber.d("File ${file.fileName} is already synchronized")
+                                            filesAlreadySynced++
+                                        }
+                                        is SynchronizeFileUseCase.SyncType.FileNotFound -> {
+                                            Timber.w("File ${file.fileName} was not found on server")
+                                            filesNotFound++
+                                        }
+                                    }
+                                }
+                                is UseCaseResult.Error -> {
+                                    Timber.e(useCaseResult.throwable, "Error syncing file ${file.fileName}")
+                                    errors++
+                                }
+                            }
+                        } catch (e: Exception) {
+                            Timber.e(e, "Error syncing file ${file.fileName}")
+                            errors++
+                        }
+                    }
+                }
+            }
+
+            val summary = buildString {
+                append("Checked: $totalFilesChecked")
+                if (filesUploaded > 0) append(" | Uploaded: $filesUploaded")
+                if (filesDownloaded > 0) append(" | Downloaded: $filesDownloaded")
+                if (filesWithConflicts > 0) append(" | Conflicts: $filesWithConflicts")
+                if (errors > 0) append(" | Errors: $errors")
+            }
+
+            Timber.i("LocalFileSyncWorker completed: $summary")
+            
+            // Only show notification if something changed
+            if (filesUploaded > 0 || filesDownloaded > 0 || filesWithConflicts > 0) {
+                showCompletionNotification(summary)
+            }
+
+            Result.success()
+        } catch (exception: Exception) {
+            Timber.e(exception, "LocalFileSyncWorker failed")
+            Result.failure()
+        }
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                NOTIFICATION_CHANNEL_ID,
+                "Auto-Sync",
+                NotificationManager.IMPORTANCE_LOW
+            ).apply {
+                description = "Shows when local file changes are synced"
+            }
+            val notificationManager = appContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            notificationManager.createNotificationChannel(channel)
+        }
+    }
+
+    private fun showCompletionNotification(summary: String) {
+        try {
+            val notificationManager = appContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            val notification = NotificationCompat.Builder(appContext, NOTIFICATION_CHANNEL_ID)
+                .setContentTitle("Auto-Sync Complete")
+                .setContentText(summary)
+                .setSmallIcon(R.drawable.notification_icon)
+                .setAutoCancel(true)
+                .build()
+
+            notificationManager.notify(NOTIFICATION_ID, notification)
+        } catch (e: Exception) {
+            Timber.e(e, "Error showing notification")
+        }
+    }
+
+    companion object {
+        const val LOCAL_FILE_SYNC_WORKER = "LOCAL_FILE_SYNC_WORKER"
+        const val repeatInterval: Long = 5L
+        val repeatIntervalTimeUnit: TimeUnit = TimeUnit.MINUTES
+
+        private const val NOTIFICATION_CHANNEL_ID = "auto_sync_channel"
+        private const val NOTIFICATION_ID = 9002
+    }
+}
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromFileSystemWorker.kt b/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromFileSystemWorker.kt
index 218611fd6..8a7e49994 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromFileSystemWorker.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromFileSystemWorker.kt
@@ -32,10 +32,12 @@ import androidx.work.WorkerParameters
 import androidx.work.workDataOf
 import eu.opencloud.android.R
 import eu.opencloud.android.data.executeRemoteOperation
+import eu.opencloud.android.data.providers.SharedPreferencesProvider
 import eu.opencloud.android.domain.automaticuploads.model.UploadBehavior
 import eu.opencloud.android.domain.capabilities.usecases.GetStoredCapabilitiesUseCase
 import eu.opencloud.android.domain.exceptions.LocalFileNotFoundException
 import eu.opencloud.android.domain.exceptions.UnauthorizedException
+import eu.opencloud.android.domain.files.FileRepository
 import eu.opencloud.android.domain.files.usecases.CleanConflictUseCase
 import eu.opencloud.android.domain.files.usecases.GetFileByRemotePathUseCase
 import eu.opencloud.android.domain.files.usecases.GetWebDavUrlForSpaceUseCase
@@ -54,6 +56,7 @@ import eu.opencloud.android.lib.resources.files.CheckPathExistenceRemoteOperatio
 import eu.opencloud.android.lib.resources.files.CreateRemoteFolderOperation
 import eu.opencloud.android.lib.resources.files.UploadFileFromFileSystemOperation
 import eu.opencloud.android.presentation.authentication.AccountUtils
+import eu.opencloud.android.presentation.settings.security.SettingsSecurityFragment
 import eu.opencloud.android.utils.NotificationUtils
 import eu.opencloud.android.utils.RemoteFileUtils.getAvailableRemotePath
 import eu.opencloud.android.utils.UPLOAD_NOTIFICATION_CHANNEL_ID
@@ -66,6 +69,9 @@ import org.koin.core.component.inject
 import timber.log.Timber
 import java.io.File
 import java.io.IOException
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
 import kotlin.coroutines.cancellation.CancellationException
 
 class UploadFileFromFileSystemWorker(
@@ -92,6 +98,8 @@ class UploadFileFromFileSystemWorker(
     private val saveFileOrFolderUseCase: SaveFileOrFolderUseCase by inject()
     private val cleanConflictUseCase: CleanConflictUseCase by inject()
     private val getWebdavUrlForSpaceUseCase: GetWebDavUrlForSpaceUseCase by inject()
+    private val preferencesProvider: SharedPreferencesProvider by inject()
+    private val fileRepository: FileRepository by inject()
 
     // Etag in conflict required to overwrite files in server. Otherwise, the upload will be rejected.
     private var eTagInConflict: String = ""
@@ -230,7 +238,40 @@ class UploadFileFromFileSystemWorker(
                 )
             )
 
-            eTagInConflict = useCaseResult.getDataOrNull()?.etagInConflict.orEmpty()
+            val remoteFile = useCaseResult.getDataOrNull()
+            eTagInConflict = remoteFile?.etagInConflict.orEmpty()
+
+            // Check if remote file has changed since we last synced
+            // If so, we have a conflict - check user preference for handling
+            if (remoteFile != null && remoteFile.etag != remoteFile.etagInConflict) {
+                val preferLocal = preferencesProvider.getBoolean(
+                    SettingsSecurityFragment.PREFERENCE_PREFER_LOCAL_ON_CONFLICT, false
+                )
+                
+                if (!preferLocal) {
+                    // User wants conflicted copy behavior - create a local copy before uploading
+                    Timber.i("Conflict detected and user prefers conflicted copy. Creating copy of local file.")
+                    val conflictedCopyPath = createConflictedCopyPath(fileSystemPath)
+                    val copied = copyLocalFile(fileSystemPath, conflictedCopyPath)
+                    if (copied) {
+                        Timber.i("Local file copied to conflicted copy: $conflictedCopyPath")
+                        // Refresh parent folder so the conflicted copy appears
+                        try {
+                            fileRepository.refreshFolder(
+                                remotePath = remoteFile.getParentRemotePath(),
+                                accountName = account.name,
+                                spaceId = remoteFile.spaceId
+                            )
+                        } catch (e: Exception) {
+                            Timber.w(e, "Failed to refresh parent folder after creating conflicted copy")
+                        }
+                    } else {
+                        Timber.w("Failed to copy local file to conflicted copy")
+                    }
+                } else {
+                    Timber.i("Conflict detected but user prefers local version. Uploading will overwrite remote.")
+                }
+            }
 
             Timber.d("Upload will overwrite current server file with the following etag in conflict: $eTagInConflict")
         } else {
@@ -249,6 +290,29 @@ class UploadFileFromFileSystemWorker(
         }
     }
 
+    private fun createConflictedCopyPath(originalPath: String): String {
+        val file = File(originalPath)
+        val nameWithoutExt = file.nameWithoutExtension
+        val extension = file.extension
+        val timestamp = SimpleDateFormat("yyyy-MM-dd_HHmmss", Locale.US).format(Date())
+        val conflictedName = if (extension.isNotEmpty()) {
+            "${nameWithoutExt}_conflicted_copy_$timestamp.$extension"
+        } else {
+            "${nameWithoutExt}_conflicted_copy_$timestamp"
+        }
+        return File(file.parent, conflictedName).absolutePath
+    }
+
+    private fun copyLocalFile(sourcePath: String, destPath: String): Boolean {
+        return try {
+            File(sourcePath).copyTo(File(destPath), overwrite = false)
+            true
+        } catch (e: Exception) {
+            Timber.e(e, "Failed to copy local file from $sourcePath to $destPath")
+            false
+        }
+    }
+
     private fun uploadDocument(client: OpenCloudClient) {
         val getStoredCapabilitiesUseCase: GetStoredCapabilitiesUseCase by inject()
         val capabilitiesForAccount = getStoredCapabilitiesUseCase(
diff --git a/opencloudApp/src/main/res/values/setup.xml b/opencloudApp/src/main/res/values/setup.xml
index 00044de80..122d44d3d 100644
--- a/opencloudApp/src/main/res/values/setup.xml
+++ b/opencloudApp/src/main/res/values/setup.xml
@@ -11,7 +11,7 @@
     <string name="search_suggest_intent_action" formatted="false">eu.opencloud.search.users_and_groups.action.SHARE_WITH</string>
     <string name="db_file" formatted="false">opencloud.db</string>
     <string name="db_name" formatted="false">OpenCloud</string>
-    <string name="data_folder" formatted="false">opencloud</string>
+    <string name="data_folder" formatted="false">OpenCloud</string>
     <string name="log_name" formatted="false">OpenCloud_</string>
     <string name="default_display_name_for_root_folder" formatted="false">OpenCloud</string>
     <string name="user_agent">Mozilla/5.0 (Android) OpenCloud-android/%1$s</string>
diff --git a/opencloudApp/src/main/res/values/strings.xml b/opencloudApp/src/main/res/values/strings.xml
index 35e5873b9..57df15b6a 100644
--- a/opencloudApp/src/main/res/values/strings.xml
+++ b/opencloudApp/src/main/res/values/strings.xml
@@ -403,6 +403,7 @@
     <string name="new_remote_version_found_msg">A new version was found in server. Downloading…</string>
     <string name="download_enqueued_msg">Download enqueued</string>
     <string name="upload_enqueued_msg">Upload enqueued</string>
+    <string name="sync_conflict_resolved_with_copy">Conflict resolved. Your local changes were saved as a separate copy.</string>
     <string name="create_dir_fail_msg">Folder could not be created</string>
     <string name="create_file_fail_msg">File could not be created</string>
     <string name="filename_forbidden_characters">Forbidden characters: / \\</string>
@@ -853,4 +854,20 @@
     <string name="release_notes_title_enhanced_bottom_nav_bar">Added text labels on bottom bar</string>
     <string name="release_notes_subtitle_bottom_nav_bar">Text labels were added and default active indicator is used to show which section is selected on the bottom bar</string>
 
+    <!-- Download Everything Feature -->
+    <string name="prefs_download_everything">Download all files</string>
+    <string name="prefs_download_everything_summary">Download all files from your cloud for offline access (requires significant storage)</string>
+    <string name="download_everything_warning_title">Download Everything</string>
+    <string name="download_everything_warning_message">This will download ALL files from your cloud. This may use significant storage space and bandwidth. Continue?</string>
+
+    <!-- Auto-Sync Feature -->
+    <string name="prefs_auto_sync">Auto-sync local changes</string>
+    <string name="prefs_auto_sync_summary">Automatically upload changes to locally modified files</string>
+    <string name="auto_sync_warning_title">Auto-Sync</string>
+    <string name="auto_sync_warning_message">Local file changes will be automatically synced to the cloud. This requires a stable network connection. Continue?</string>
+
+    <!-- Conflict Resolution -->
+    <string name="prefs_prefer_local_on_conflict">Prefer local version on conflict</string>
+    <string name="prefs_prefer_local_on_conflict_summary">When a file is modified both locally and on server, upload local version instead of creating a conflicted copy</string>
+
 </resources>
diff --git a/opencloudApp/src/main/res/xml/settings_security.xml b/opencloudApp/src/main/res/xml/settings_security.xml
index 91c72bb0d..3e2888145 100644
--- a/opencloudApp/src/main/res/xml/settings_security.xml
+++ b/opencloudApp/src/main/res/xml/settings_security.xml
@@ -49,4 +49,25 @@
         app:summary="@string/prefs_touches_with_other_visible_windows_summary"
         app:title="@string/prefs_touches_with_other_visible_windows" />
 
+    <!-- Download Everything Feature -->
+    <CheckBoxPreference
+        app:iconSpaceReserved="false"
+        app:key="download_everything"
+        app:summary="@string/prefs_download_everything_summary"
+        app:title="@string/prefs_download_everything" />
+
+    <!-- Auto-Sync Feature -->
+    <CheckBoxPreference
+        app:iconSpaceReserved="false"
+        app:key="auto_sync_local_changes"
+        app:summary="@string/prefs_auto_sync_summary"
+        app:title="@string/prefs_auto_sync" />
+
+    <!-- Conflict Resolution Strategy -->
+    <CheckBoxPreference
+        app:iconSpaceReserved="false"
+        app:key="prefer_local_on_conflict"
+        app:summary="@string/prefs_prefer_local_on_conflict_summary"
+        app:title="@string/prefs_prefer_local_on_conflict" />
+
 </PreferenceScreen>
\ No newline at end of file
diff --git a/opencloudComLibrary/src/main/java/eu/opencloud/android/lib/resources/users/GetRemoteUserAvatarOperation.kt b/opencloudComLibrary/src/main/java/eu/opencloud/android/lib/resources/users/GetRemoteUserAvatarOperation.kt
index 9e355c03c..e6ba9bd6f 100644
--- a/opencloudComLibrary/src/main/java/eu/opencloud/android/lib/resources/users/GetRemoteUserAvatarOperation.kt
+++ b/opencloudComLibrary/src/main/java/eu/opencloud/android/lib/resources/users/GetRemoteUserAvatarOperation.kt
@@ -31,7 +31,6 @@ import eu.opencloud.android.lib.common.network.WebdavUtils
 import eu.opencloud.android.lib.common.operations.RemoteOperation
 import eu.opencloud.android.lib.common.operations.RemoteOperationResult
 import timber.log.Timber
-import java.io.File
 import java.io.IOException
 import java.io.InputStream
 import java.net.URL
@@ -48,8 +47,7 @@ class GetRemoteUserAvatarOperation(private val avatarDimension: Int) : RemoteOpe
         var result: RemoteOperationResult<RemoteAvatarData>
 
         try {
-            val endPoint =
-                client.baseUri.toString() + NON_OFFICIAL_AVATAR_PATH + client.credentials.username + File.separator + avatarDimension
+            val endPoint = client.baseUri.toString() + GRAPH_AVATAR_PATH
             Timber.d("avatar URI: %s", endPoint)
 
             val getMethod = GetMethod(URL(endPoint))
@@ -109,6 +107,6 @@ class GetRemoteUserAvatarOperation(private val avatarDimension: Int) : RemoteOpe
     private fun isSuccess(status: Int) = status == HttpConstants.HTTP_OK
 
     companion object {
-        private const val NON_OFFICIAL_AVATAR_PATH = "/index.php/avatar/"
+        private const val GRAPH_AVATAR_PATH = "/graph/v1.0/me/photo/\$value"
     }
 }
diff --git a/opencloudData/src/main/java/eu/opencloud/android/data/providers/LocalStorageProvider.kt b/opencloudData/src/main/java/eu/opencloud/android/data/providers/LocalStorageProvider.kt
index c41846fa6..fde8bdcfb 100644
--- a/opencloudData/src/main/java/eu/opencloud/android/data/providers/LocalStorageProvider.kt
+++ b/opencloudData/src/main/java/eu/opencloud/android/data/providers/LocalStorageProvider.kt
@@ -49,7 +49,10 @@ sealed class LocalStorageProvider(private val rootFolderName: String) {
     /**
      * Get local storage path for accountName.
      */
-    private fun getAccountDirectoryPath(
+    /**
+     * Get local storage path for accountName.
+     */
+    protected open fun getAccountDirectoryPath(
         accountName: String
     ): String = getRootFolderPath() + File.separator + getEncodedAccountName(accountName)
 
@@ -62,9 +65,15 @@ sealed class LocalStorageProvider(private val rootFolderName: String) {
         accountName: String,
         remotePath: String,
         spaceId: String?,
+        spaceName: String? = null,
     ): String =
         if (spaceId != null) {
-            getAccountDirectoryPath(accountName) + File.separator + spaceId + File.separator + remotePath
+            val spaceFolder = if (!spaceName.isNullOrBlank()) {
+                spaceName.replace("/", "_").replace("\\", "_").replace(":", "_")
+            } else {
+                spaceId
+            }
+            getAccountDirectoryPath(accountName) + File.separator + spaceFolder + File.separator + remotePath
         } else {
             getAccountDirectoryPath(accountName) + remotePath
         }
diff --git a/opencloudData/src/main/java/eu/opencloud/android/data/providers/ScopedStorageProvider.kt b/opencloudData/src/main/java/eu/opencloud/android/data/providers/ScopedStorageProvider.kt
index a9a4c996c..3ff9bd60a 100644
--- a/opencloudData/src/main/java/eu/opencloud/android/data/providers/ScopedStorageProvider.kt
+++ b/opencloudData/src/main/java/eu/opencloud/android/data/providers/ScopedStorageProvider.kt
@@ -20,6 +20,7 @@
 package eu.opencloud.android.data.providers
 
 import android.content.Context
+import android.os.Environment
 import java.io.File
 
 class ScopedStorageProvider(
@@ -27,5 +28,10 @@ class ScopedStorageProvider(
     private val context: Context
 ) : LocalStorageProvider(rootFolderName) {
 
-    override fun getPrimaryStorageDirectory(): File = context.filesDir
+    override fun getPrimaryStorageDirectory(): File = Environment.getExternalStorageDirectory()
+
+    override fun getAccountDirectoryPath(accountName: String): String {
+        val sanitizedName = accountName.replace("/", "_").replace("\\", "_").replace(":", "_")
+        return getRootFolderPath() + File.separator + sanitizedName
+    }
 }