From 8533b9833c25756c5106210cec8f6707c98b5761 Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Thu, 9 Jul 2026 15:58:47 +0200
Subject: [PATCH 01/19] Improve TLS cert validation

This addresses a logic issue in the previous check for TLS certs introduced with the option to ignore CRL failures. Since the call would end up calling `.Verify()` on the certificate, even toggling for soft-fail CRL issues, the certificate would be rejected.

With the new logic we manually verify the chain. This is only done if the user has requested specific certificates should be validated as we otherwise rely on the OS cert validation.
---
 Duplicati/Library/Backend/WEBDAV/WEBDAV.cs    |  6 +-
 .../Utility/SslCertificateValidator.cs        | 76 ++++++++++++++++++-
 2 files changed, 74 insertions(+), 8 deletions(-)

diff --git a/Duplicati/Library/Backend/WEBDAV/WEBDAV.cs b/Duplicati/Library/Backend/WEBDAV/WEBDAV.cs
index e1d4586c0..5a1a4a104 100644
--- a/Duplicati/Library/Backend/WEBDAV/WEBDAV.cs
+++ b/Duplicati/Library/Backend/WEBDAV/WEBDAV.cs
@@ -365,11 +365,7 @@ namespace Duplicati.Library.Backend
             if (m_httpClient == null)
             {
                 var httpHandler = new HttpClientHandler();
-
-                // Custom certificate validation to throw exception on failure
-                var validator = new SslCertificateValidator(m_certificateOptions.AcceptAllCertificates, m_certificateOptions.AcceptSpecificCertificateHashes, m_certificateOptions.IgnoreRevocationFailure);
-                httpHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) =>
-                    validator.ValidateServerCertificate(sender, cert, chain, sslPolicyErrors);
+                HttpClientHelper.ConfigureHandlerCertificateValidator(httpHandler, m_certificateOptions.AcceptAllCertificates, m_certificateOptions.AcceptSpecificCertificateHashes, m_certificateOptions.IgnoreRevocationFailure);
 
                 if (m_useIntegratedAuthentication)
                 {
diff --git a/Duplicati/Library/Utility/SslCertificateValidator.cs b/Duplicati/Library/Utility/SslCertificateValidator.cs
index cec74f9b7..8c2b320eb 100644
--- a/Duplicati/Library/Utility/SslCertificateValidator.cs
+++ b/Duplicati/Library/Utility/SslCertificateValidator.cs
@@ -59,7 +59,10 @@ public class SslCertificateValidator(bool acceptAll, string[]? validHashes, bool
 
             using var certificate = cert as X509Certificate2 ?? new X509Certificate2(cert ?? throw new ArgumentNullException(nameof(cert)));
 
-            // Validate date range before anything else, reject expired certs
+            // Validate date range before anything else, reject expired certs.
+            // NotBefore/NotAfter are returned by .NET as DateTime with Kind=Local (the UTC
+            // instant expressed in local time), so DateTime.Now (also Kind=Local) is the
+            // correct comparison; using UtcNow here would skew the window by the timezone offset.
             if (!IsDateValid(certificate, now))
                 return false;
 
@@ -77,7 +80,11 @@ public class SslCertificateValidator(bool acceptAll, string[]? validHashes, bool
             }
 
 
-            // If requested, ignore revocation check failures (e.g. OCSP server offline or status unknown)
+            // If requested, ignore revocation check failures (e.g. OCSP server offline or status unknown).
+            // This strips revocation-only flags from the sslPolicyErrors that the TLS stack reported using
+            // its own chain object. The explicit chain built below operates on a separate X509Chain and
+            // applies the same soft-fail logic independently, so both the reported-policy path and the
+            // verify path honor ignoreRevocationFailure consistently.
             if (ignoreRevocationFailure)
                 sslPolicyErrors = FilterRevocationErrors(sslPolicyErrors, chain);
 
@@ -85,7 +92,70 @@ public class SslCertificateValidator(bool acceptAll, string[]? validHashes, bool
                 throw new InvalidCertificateException(certificate.GetCertHashString(), sslPolicyErrors);
 
             // If no hash is found, perform the standard validations
-            return sslPolicyErrors == SslPolicyErrors.None && certificate.Verify();
+            if (sslPolicyErrors != SslPolicyErrors.None)
+                return false;
+
+            // certificate.Verify() builds its own X509Chain with a default policy that
+            // hard-fails when a revocation check cannot be completed (OCSP/CRL endpoint
+            // unreachable). The OS-native TLS stacks instead soft-fail in that situation:
+            // the certificate is accepted when the revocation status is merely unknown
+            // (not confirmed revoked). Build the chain explicitly so we can replicate that
+            // behavior and honor the ignoreRevocationFailure setting.
+            //
+            // Note: ChainPolicy.TrustMode is left at its default (UseSystemDefault), which
+            // resolves intermediate/root trust through the OS trust store exactly as
+            // certificate.Verify() did, so the trust-root behaviour of the previous
+            // implementation is preserved.
+            using var verifyChain = new X509Chain();
+            // The primary mechanism for honoring ignoreRevocationFailure: skip the online
+            // revocation fetch entirely so an unreachable OCSP/CRL endpoint cannot fail the
+            // chain. The post-build soft-fail below is a safety net for platforms that
+            // still surface revocation status flags even under NoCheck, not the main path.
+            verifyChain.ChainPolicy.RevocationMode =
+                ignoreRevocationFailure ? X509RevocationMode.NoCheck : X509RevocationMode.Online;
+            bool chainValid = verifyChain.Build(certificate);
+
+            // Soft-fail on unreachable revocation checks, but only when the caller has
+            // explicitly requested it via ignoreRevocationFailure. This replicates the
+            // OS-native TLS behavior of accepting a certificate whose revocation status is
+            // merely unknown (OCSP/CRL endpoint unreachable) rather than confirmed revoked.
+            //
+            // This block is a safety net for the NoCheck mode above: on some platforms
+            // Build() can still report revocation-related flags despite RevocationMode being
+            // NoCheck, so strip those flags here rather than relying on NoCheck alone.
+            //
+            // The guard requires a non-empty ChainStatus: if Build() returned false with no
+            // status flags (rare platform edge case), we must not silently accept the
+            // certificate, as that would widen trust beyond what any status indicates.
+            // A confirmed Revoked flag, PartialChain, or any other non-revocation status
+            // still fails the chain because the All() predicate would be false. The using
+            // scope ensures verifyChain is disposed even if Build() throws and the outer
+            // catch wraps the exception.
+            if (!chainValid && ignoreRevocationFailure && verifyChain.ChainStatus.Length > 0 &&
+                verifyChain.ChainStatus.All(s => (s.Status & ~RevocationFailureFlags) == 0))
+                chainValid = true;
+
+            if (!chainValid)
+            {
+                var chainStatus = string.Join("; ", verifyChain.ChainStatus.Select(s => $"{s.Status}={s.StatusInformation?.Trim()}"));
+                var elementDetails = verifyChain.ChainElements.Count == 0
+                    ? "(no chain elements)"
+                    : string.Join(" | ", verifyChain.ChainElements.Select(e =>
+                    {
+                        var elemStatus = e.ChainElementStatus.Length == 0
+                            ? "(none)"
+                            : string.Join(", ", e.ChainElementStatus.Select(s => $"{s.Status}={s.StatusInformation?.Trim()}"));
+                        return $"{e.Certificate.Subject} [{elemStatus}]";
+                    }));
+
+                Duplicati.Library.Logging.Log.WriteWarningMessage(
+                    "SslCertificateValidator",
+                    "VerifyChainFailed",
+                    null,
+                    $"Certificate chain validation failed for {certificate.Subject} (issuer={certificate.Issuer}, " +
+                    $"thumbprint={certificate.Thumbprint}). Chain status: {chainStatus}. Per-element: {elementDetails}");
+            }
+            return chainValid;
         }
         catch (InvalidCertificateException)
         {

From 95b7ed29e2a8f4efe575d8c1fc43ede0935fd62a Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Fri, 10 Jul 2026 20:17:38 +0900
Subject: [PATCH 02/19] Avoid secondary transaction errors after repair failure

---
 .../Main/Database/ReusableTransaction.cs      | 26 +++++++++--
 Duplicati/UnitTest/Issue5827.cs               | 44 +++++++++++++++++++
 2 files changed, 67 insertions(+), 3 deletions(-)
 create mode 100644 Duplicati/UnitTest/Issue5827.cs

diff --git a/Duplicati/Library/Main/Database/ReusableTransaction.cs b/Duplicati/Library/Main/Database/ReusableTransaction.cs
index 3e107369b..ac38d30b8 100644
--- a/Duplicati/Library/Main/Database/ReusableTransaction.cs
+++ b/Duplicati/Library/Main/Database/ReusableTransaction.cs
@@ -121,17 +121,37 @@ internal class ReusableTransaction(SqliteConnection con, SqliteTransaction? tran
             }
             catch (Exception ex)
             {
-                Logging.Log.WriteErrorMessage(LOGTAG, "ReusableTransaction dispose", ex, "Transaction disposed with error: {0}", ex.Message);
-                throw;
+                if (!IsInactiveTransactionException(ex))
+                {
+                    Logging.Log.WriteErrorMessage(LOGTAG, "ReusableTransaction dispose", ex, "Transaction disposed with error: {0}", ex.Message);
+                    throw;
+                }
+
+                Logging.Log.WriteVerboseMessage(LOGTAG, "ReusableTransactionAlreadyCompleted", ex, "Transaction was already completed during dispose: {0}", ex.Message);
             }
             finally
             {
                 m_disposed = true;
-                await m_transaction.DisposeAsync().ConfigureAwait(false);
+                try
+                {
+                    await m_transaction.DisposeAsync().ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    if (!IsInactiveTransactionException(ex))
+                        throw;
+
+                    Logging.Log.WriteVerboseMessage(LOGTAG, "ReusableTransactionAlreadyDisposed", ex, "Transaction was already completed before dispose: {0}", ex.Message);
+                }
             }
         }
     }
 
+    private static bool IsInactiveTransactionException(Exception ex)
+        => ex.Message.Contains("No transaction is active", StringComparison.OrdinalIgnoreCase)
+        || ex.Message.Contains("transaction has completed", StringComparison.OrdinalIgnoreCase)
+        || ex.Message.Contains("no longer usable", StringComparison.OrdinalIgnoreCase);
+
     /// <summary>
     /// Rolls back the transaction and restarts it.
     /// </summary>
diff --git a/Duplicati/UnitTest/Issue5827.cs b/Duplicati/UnitTest/Issue5827.cs
new file mode 100644
index 000000000..ec653818a
--- /dev/null
+++ b/Duplicati/UnitTest/Issue5827.cs
@@ -0,0 +1,44 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System.Threading.Tasks;
+using Duplicati.Library.Main.Database;
+using Microsoft.Data.Sqlite;
+using NUnit.Framework;
+
+namespace Duplicati.UnitTest;
+
+public class Issue5827
+{
+    [Test]
+    public async Task DisposeDoesNotThrowWhenTransactionAlreadyCompletedAsync()
+    {
+        await using var connection = new SqliteConnection("Data Source=:memory:");
+        await connection.OpenAsync();
+
+        var transaction = (SqliteTransaction)await connection.BeginTransactionAsync();
+        await using var reusableTransaction = new ReusableTransaction(connection, transaction);
+
+        await transaction.CommitAsync();
+
+        Assert.DoesNotThrowAsync(async () => await reusableTransaction.DisposeAsync().AsTask());
+    }
+}

From 069c838ccbaf00e75248cffd913ccef8c92953e3 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Fri, 10 Jul 2026 20:36:43 +0900
Subject: [PATCH 03/19] Address review: warn on inactive-transaction dispose,
 match by exception type

- Log the "transaction already completed/disposed" cases as warnings instead of
  verbose messages, so they are captured in tests and the underlying issue can be
  fixed (per review feedback).
- Replace the fragile message-string matching in IsInactiveTransactionException
  with an exception-type check. Microsoft.Data.Sqlite throws InvalidOperationException
  ("This SqliteTransaction has completed; it is no longer usable.") for an
  already-completed transaction; matching the type avoids breaking under
  localization or matching unintended messages (verified locally via the Issue5827
  test, which catches System.InvalidOperationException).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../Library/Main/Database/ReusableTransaction.cs      | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/Duplicati/Library/Main/Database/ReusableTransaction.cs b/Duplicati/Library/Main/Database/ReusableTransaction.cs
index ac38d30b8..b9b36039f 100644
--- a/Duplicati/Library/Main/Database/ReusableTransaction.cs
+++ b/Duplicati/Library/Main/Database/ReusableTransaction.cs
@@ -127,7 +127,7 @@ internal class ReusableTransaction(SqliteConnection con, SqliteTransaction? tran
                     throw;
                 }
 
-                Logging.Log.WriteVerboseMessage(LOGTAG, "ReusableTransactionAlreadyCompleted", ex, "Transaction was already completed during dispose: {0}", ex.Message);
+                Logging.Log.WriteWarningMessage(LOGTAG, "ReusableTransactionAlreadyCompleted", ex, "Transaction was already completed during dispose: {0}", ex.Message);
             }
             finally
             {
@@ -141,16 +141,17 @@ internal class ReusableTransaction(SqliteConnection con, SqliteTransaction? tran
                     if (!IsInactiveTransactionException(ex))
                         throw;
 
-                    Logging.Log.WriteVerboseMessage(LOGTAG, "ReusableTransactionAlreadyDisposed", ex, "Transaction was already completed before dispose: {0}", ex.Message);
+                    Logging.Log.WriteWarningMessage(LOGTAG, "ReusableTransactionAlreadyDisposed", ex, "Transaction was already completed before dispose: {0}", ex.Message);
                 }
             }
         }
     }
 
+    // Microsoft.Data.Sqlite throws InvalidOperationException ("This SqliteTransaction has completed;
+    // it is no longer usable.") when a transaction is rolled back or disposed after it has already
+    // been completed. Match on the exception type rather than the (localizable) message text.
     private static bool IsInactiveTransactionException(Exception ex)
-        => ex.Message.Contains("No transaction is active", StringComparison.OrdinalIgnoreCase)
-        || ex.Message.Contains("transaction has completed", StringComparison.OrdinalIgnoreCase)
-        || ex.Message.Contains("no longer usable", StringComparison.OrdinalIgnoreCase);
+        => ex is InvalidOperationException;
 
     /// <summary>
     /// Rolls back the transaction and restarts it.

From c091b3e6fc78de55ef7ec2bc1820714413614a07 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Fri, 10 Jul 2026 21:56:03 +0900
Subject: [PATCH 04/19] Make CLI find search all backup versions by default
 (fixes #2287)

The `find` and `list` commands share the same handler. A bare filename is
rewritten to a wildcard filter (e.g. `*/report.txt`), and the handler only
searches every version for a Simple filter or when --all-versions is set, so a
wildcard filter searches only the newest version. The all-versions fallback in
Commands.List only triggers when the newest pass returns zero files, so a file
present only in an older version was silently missed whenever the newest version
still contained a same-named file (and full-path finds behaved differently from
bare-name finds).

Give `find` its own entry point that defaults to all-versions (respecting an
explicit --all-versions/--version/--time), so `find <name>` reliably searches
every backup version. `list` keeps its documented newest-only default. Update the
help text and add a regression test (Issue2287) that a file present only in an
older version is found by `find` but not by `list`.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 Duplicati/CommandLine/CLI/Commands.cs |  11 +++
 Duplicati/CommandLine/CLI/Program.cs  |   4 +-
 Duplicati/CommandLine/CLI/help.txt    |   2 +-
 Duplicati/UnitTest/Issue2287.cs       | 100 ++++++++++++++++++++++++++
 4 files changed, 114 insertions(+), 3 deletions(-)
 create mode 100644 Duplicati/UnitTest/Issue2287.cs

diff --git a/Duplicati/CommandLine/CLI/Commands.cs b/Duplicati/CommandLine/CLI/Commands.cs
index b2376a3ec..f8e4f4892 100644
--- a/Duplicati/CommandLine/CLI/Commands.cs
+++ b/Duplicati/CommandLine/CLI/Commands.cs
@@ -498,6 +498,17 @@ namespace Duplicati.CommandLine
             return 0;
         }
 
+        public static int Find(TextWriter outwriter, Action<Duplicati.Library.Main.Controller> setup, List<string> args, Dictionary<string, string> options, Library.Utility.IFilter filter)
+        {
+            // Unlike "list" (which shows only the newest version by default), "find" searches every
+            // backup version, so a file is located regardless of which version it appears in.
+            // Respect an explicit --all-versions / --version / --time supplied by the user.
+            if (!options.ContainsKey("all-versions") && !options.ContainsKey("version") && !options.ContainsKey("time"))
+                options["all-versions"] = "true";
+
+            return List(outwriter, setup, args, options, filter);
+        }
+
         public static int List(TextWriter outwriter, Action<Duplicati.Library.Main.Controller> setup, List<string> args, Dictionary<string, string> options, Library.Utility.IFilter filter)
         {
             filter = filter ?? new Duplicati.Library.Utility.FilterExpression();
diff --git a/Duplicati/CommandLine/CLI/Program.cs b/Duplicati/CommandLine/CLI/Program.cs
index 4886e856f..1a2f0150b 100644
--- a/Duplicati/CommandLine/CLI/Program.cs
+++ b/Duplicati/CommandLine/CLI/Program.cs
@@ -76,7 +76,7 @@ namespace Duplicati.CommandLine
                         ["help"] = Commands.Help,
                         ["example"] = Commands.Examples,
                         ["examples"] = Commands.Examples,
-                        ["find"] = Commands.List,
+                        ["find"] = Commands.Find,
                         ["list"] = Commands.List,
                         ["list-filesets"] = Commands.ListFilesets,
                         ["list-folder-content"] = Commands.ListFolderContent,
@@ -107,7 +107,7 @@ namespace Duplicati.CommandLine
                         ["readlockinfo"] = Commands.ReadLockInfo,
                         ["system-info"] = Commands.SystemInfo,
                         ["systeminfo"] = Commands.SystemInfo,
-                        ["send-mail"] = Commands.SendMail,
+                        ["send-mail"] = Commands.SendMail,
                         ["sync"] = Commands.Sync
                     };
 
diff --git a/Duplicati/CommandLine/CLI/help.txt b/Duplicati/CommandLine/CLI/help.txt
index 815996de9..5956711ce 100644
--- a/Duplicati/CommandLine/CLI/help.txt
+++ b/Duplicati/CommandLine/CLI/help.txt
@@ -103,7 +103,7 @@ Usage: %CLI_EXE% backup <storage-URL> "<source-path>" [<options>]
 
 Usage: %CLI_EXE% find <storage-URL> ["<filename>"] [<options>]
 
-  Finds specific files in specific backups. If <filename> is specified, all occurrences of <filename> in the backup are listed. <filename> can contain * and ? as wildcards. File names in [brackets] are interpreted as regular expression. Latest backup is searched by default. If entire path is specified, all available versions of the file are listed. If no <filename> is specified, a list of all available backups is shown.
+  Finds specific files in specific backups. If <filename> is specified, all occurrences of <filename> in the backup are listed. <filename> can contain * and ? as wildcards. File names in [brackets] are interpreted as regular expression. The "find" command searches all backup versions by default, while "list" shows only the latest version by default (use --all-versions with "list" to search every version). If no <filename> is specified, a list of all available backups is shown.
 
   --time=<time>
     Shows what the files looked like at a specific time. Absolute and relative times can be specified.
diff --git a/Duplicati/UnitTest/Issue2287.cs b/Duplicati/UnitTest/Issue2287.cs
new file mode 100644
index 000000000..176850039
--- /dev/null
+++ b/Duplicati/UnitTest/Issue2287.cs
@@ -0,0 +1,100 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Duplicati.UnitTest
+{
+    public class Issue2287 : BasicSetupHelper
+    {
+        /// <summary>
+        /// https://github.com/duplicati/duplicati/issues/2287
+        /// The "find" command must locate a file in ANY backup version, not only the newest one.
+        /// A bare filename is turned into a wildcard filter (e.g. "*/target.txt"), which previously
+        /// searched only the newest version; the all-versions fallback only triggered when the newest
+        /// version had zero matches, so a file present only in an older version was silently missed
+        /// whenever the newest version still contained a same-named file. "find" now searches all
+        /// versions by default, while "list" keeps its newest-only default.
+        /// </summary>
+        [Test]
+        [Category("Targeted")]
+        public async Task FindSearchesAllVersionsAsync()
+        {
+            var testopts = TestOptions.Expand(new { no_encryption = true });
+
+            var subA = Path.Combine(DATAFOLDER, "sub_a");
+            var subB = Path.Combine(DATAFOLDER, "sub_b");
+            Directory.CreateDirectory(subA);
+            Directory.CreateDirectory(subB);
+            var fileA = Path.Combine(subA, "target.txt");
+            var fileB = Path.Combine(subB, "target.txt");
+            File.WriteAllText(fileA, "present in newest and old version");
+            File.WriteAllText(fileB, "present only in the old version");
+
+            // Version 1: both sub_a/target.txt and sub_b/target.txt exist.
+            using (var c = new Library.Main.Controller("file://" + TARGETFOLDER, testopts, null))
+            {
+                var res = await c.BackupAsync(new[] { DATAFOLDER });
+                Assert.AreEqual(0, res.Errors.Count());
+            }
+
+            System.Threading.Thread.Sleep(TimeSpan.FromSeconds(3));
+
+            // Version 0 (newest): sub_b/target.txt is removed, so it now exists only in the old version.
+            File.Delete(fileB);
+            Directory.Delete(subB);
+            using (var c = new Library.Main.Controller("file://" + TARGETFOLDER, testopts, null))
+            {
+                var res = await c.BackupAsync(new[] { DATAFOLDER });
+                Assert.AreEqual(0, res.Errors.Count());
+            }
+
+            // "find target.txt" must surface the older-only sub_b/target.txt as well as the newest one.
+            var findOutput = RunListCommand(Duplicati.CommandLine.Commands.Find, "target.txt", testopts);
+            Assert.IsTrue(findOutput.Contains("sub_a"), "find should list the newest match:" + Environment.NewLine + findOutput);
+            Assert.IsTrue(findOutput.Contains("sub_b"), "find should also list the older-only match:" + Environment.NewLine + findOutput);
+
+            // "list target.txt" keeps the newest-only behaviour, so it must NOT include the older-only file.
+            var listOutput = RunListCommand(Duplicati.CommandLine.Commands.List, "target.txt", testopts);
+            Assert.IsTrue(listOutput.Contains("sub_a"), "list should list the newest match:" + Environment.NewLine + listOutput);
+            Assert.IsFalse(listOutput.Contains("sub_b"), "list should not list the older-only match:" + Environment.NewLine + listOutput);
+        }
+
+        private string RunListCommand(
+            Func<TextWriter, Action<Library.Main.Controller>, List<string>, Dictionary<string, string>, Library.Utility.IFilter, int> command,
+            string filename,
+            Dictionary<string, string> baseopts)
+        {
+            using var sw = new StringWriter();
+            // The list/find commands mutate the args and options, so hand each invocation its own copies.
+            var args = new List<string> { "file://" + TARGETFOLDER, filename };
+            var opts = new Dictionary<string, string>(baseopts);
+            command(sw, _ => { }, args, opts, null);
+            return sw.ToString();
+        }
+    }
+}

From e72bf15050831398b76f8e18364a7dd1cfbd13ac Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Fri, 10 Jul 2026 15:07:58 +0200
Subject: [PATCH 05/19] Prevent tests toggling powermode

This PR disables sleep prevention in tests.
This replaces #7028
---
 Duplicati/UnitTest/BasicSetupHelper.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Duplicati/UnitTest/BasicSetupHelper.cs b/Duplicati/UnitTest/BasicSetupHelper.cs
index 4fe16f4f5..d917c3a0f 100644
--- a/Duplicati/UnitTest/BasicSetupHelper.cs
+++ b/Duplicati/UnitTest/BasicSetupHelper.cs
@@ -193,6 +193,7 @@ namespace Duplicati.UnitTest
                 opts["blocksize"] = "10kb";
                 opts["backup-test-samples"] = "0";
                 opts["unittest-mode"] = "true";
+                opts["allow-sleep"] = "true";
                 if (OperatingSystem.IsWindows() || OperatingSystem.IsLinux())
                     opts["snapshot-policy"] = "Off";
 

From cf10b8274a8359b7259076f3ab9e9a3584495272 Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Fri, 10 Jul 2026 15:08:41 +0200
Subject: [PATCH 06/19] Also disable snapshots on MacOS

---
 Duplicati/UnitTest/BasicSetupHelper.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Duplicati/UnitTest/BasicSetupHelper.cs b/Duplicati/UnitTest/BasicSetupHelper.cs
index d917c3a0f..06e454deb 100644
--- a/Duplicati/UnitTest/BasicSetupHelper.cs
+++ b/Duplicati/UnitTest/BasicSetupHelper.cs
@@ -194,8 +194,7 @@ namespace Duplicati.UnitTest
                 opts["backup-test-samples"] = "0";
                 opts["unittest-mode"] = "true";
                 opts["allow-sleep"] = "true";
-                if (OperatingSystem.IsWindows() || OperatingSystem.IsLinux())
-                    opts["snapshot-policy"] = "Off";
+                opts["snapshot-policy"] = "Off";
 
                 return opts;
             }

From d4e1efc137c5e53e74f94748492b7a2289958395 Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Fri, 10 Jul 2026 15:22:41 +0200
Subject: [PATCH 07/19] Tried a bit more specific capture

---
 Duplicati/Library/Main/Database/ReusableTransaction.cs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/Duplicati/Library/Main/Database/ReusableTransaction.cs b/Duplicati/Library/Main/Database/ReusableTransaction.cs
index b9b36039f..0372b8d37 100644
--- a/Duplicati/Library/Main/Database/ReusableTransaction.cs
+++ b/Duplicati/Library/Main/Database/ReusableTransaction.cs
@@ -149,9 +149,12 @@ internal class ReusableTransaction(SqliteConnection con, SqliteTransaction? tran
 
     // Microsoft.Data.Sqlite throws InvalidOperationException ("This SqliteTransaction has completed;
     // it is no longer usable.") when a transaction is rolled back or disposed after it has already
-    // been completed. Match on the exception type rather than the (localizable) message text.
+    // been completed. Unfortunately there is nothing specific that can be used to differentiate it
+    // from other exceptions that might occur during disposal, so we rely on the exception type, source and message.
     private static bool IsInactiveTransactionException(Exception ex)
-        => ex is InvalidOperationException;
+        => ex is InvalidOperationException
+            && ex.Source == "Microsoft.Data.Sqlite"
+            && ex.Message.StartsWith("This SqliteTransaction has completed", StringComparison.Ordinal);
 
     /// <summary>
     /// Rolls back the transaction and restarts it.

From 68dedaa32055704bb3d77594121a9d83ee4e9fa2 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Fri, 10 Jul 2026 22:28:27 +0900
Subject: [PATCH 08/19] Use effective dbpath for show-log and delete-db
 endpoints (fixes #1698)

A backup can have two notions of its local database path: the stored
Backup.DBPath field and a --dbpath advanced option in its settings. The runner
computes an effective path that lets --dbpath override Backup.DBPath, so most
operations honor it. But the "Show log", "Show remote log" and "Delete database"
endpoints read Backup.DBPath directly, so when --dbpath differs they open/delete
the wrong database - "Show log" then fails with "no such table: LogData".

Add a shared Runner.GetEffectiveDBPath(IBackup) helper (same precedence as
Runner.ApplyOptions) and use it in ExecuteGetLog, ExecuteGetRemotelog and
ExecuteDeleteDb so all operations agree on the database file. Adds a unit test
for the precedence.

The database move/update endpoints are intentionally left unchanged, as they
manage the DBPath field itself.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 Duplicati/Library/RestAPI/Runner.cs           | 13 +++
 Duplicati/UnitTest/Issue1698.cs               | 91 +++++++++++++++++++
 .../Endpoints/V1/Backup/BackupGet.cs          | 12 ++-
 .../Endpoints/V1/Backup/BackupPost.cs         |  4 +-
 4 files changed, 115 insertions(+), 5 deletions(-)
 create mode 100644 Duplicati/UnitTest/Issue1698.cs

diff --git a/Duplicati/Library/RestAPI/Runner.cs b/Duplicati/Library/RestAPI/Runner.cs
index 8640e8ad6..0eeca7139 100644
--- a/Duplicati/Library/RestAPI/Runner.cs
+++ b/Duplicati/Library/RestAPI/Runner.cs
@@ -1412,6 +1412,19 @@ namespace Duplicati.Server
             options["remote-sync-json-config"] = JsonSerializer.Serialize(config, jsonOptions);
         }
 
+        /// <summary>
+        /// Returns the effective local database path for a backup: the "--dbpath" advanced option if
+        /// it is set, otherwise the stored <see cref="Serialization.Interface.IBackup.DBPath"/>. This
+        /// mirrors the precedence applied by <see cref="ApplyOptions"/> so that every operation agrees
+        /// on which database file to use (see issue #1698).
+        /// </summary>
+        public static string GetEffectiveDBPath(Serialization.Interface.IBackup backup)
+        {
+            var dbpath = backup.Settings?
+                .FirstOrDefault(s => s.Name.Equals("--dbpath", StringComparison.OrdinalIgnoreCase))?.Value;
+            return string.IsNullOrWhiteSpace(dbpath) ? backup.DBPath : dbpath;
+        }
+
         internal static Dictionary<string, string?> ApplyOptions(Connection databaseConnection, Serialization.Interface.IBackup backup, Dictionary<string, string?> options, out string url)
         {
             url = backup.TargetURL;
diff --git a/Duplicati/UnitTest/Issue1698.cs b/Duplicati/UnitTest/Issue1698.cs
new file mode 100644
index 000000000..bb571e04f
--- /dev/null
+++ b/Duplicati/UnitTest/Issue1698.cs
@@ -0,0 +1,91 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Duplicati.Server.Database;
+using Duplicati.Server.Serialization.Interface;
+using NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Duplicati.UnitTest
+{
+    /// <summary>
+    /// https://github.com/duplicati/duplicati/issues/1698
+    /// "Show log" and "Database delete" read/deleted the stored <c>Backup.DBPath</c> directly, while
+    /// most operations honor a "--dbpath" advanced option. When those disagreed, Show log opened the
+    /// wrong/empty database ("no such table: LogData"). <see cref="Duplicati.Server.Runner.GetEffectiveDBPath"/>
+    /// reconciles them with the same precedence as the runner; these tests cover that precedence.
+    /// </summary>
+    [TestFixture]
+    public class Issue1698
+    {
+        private static Backup CreateBackup(string? storedDbPath, params (string Name, string Value)[] settings)
+        {
+            var backup = new Backup
+            {
+                ID = null,
+                Name = "Test Backup",
+                Description = "",
+                Tags = new string[0],
+                TargetURL = "file:///test",
+                Sources = new string[0],
+                Settings = settings.Select(s => (ISetting)new Setting { Name = s.Name, Value = s.Value }).ToArray(),
+                Filters = new IFilter[0],
+                Metadata = new Dictionary<string, string>()
+            };
+            if (storedDbPath != null)
+                backup.SetDBPath(storedDbPath);
+            return backup;
+        }
+
+        [Test]
+        public void UsesStoredDbPathWhenNoAdvancedOption()
+        {
+            var backup = CreateBackup("/stored/path.sqlite");
+            Assert.AreEqual("/stored/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(backup));
+        }
+
+        [Test]
+        public void AdvancedDbPathOptionOverridesStoredDbPath()
+        {
+            var backup = CreateBackup("/stored/path.sqlite", ("--dbpath", "/override/path.sqlite"));
+            Assert.AreEqual("/override/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(backup));
+        }
+
+        [Test]
+        public void AdvancedDbPathMatchIsCaseInsensitiveOnName()
+        {
+            var backup = CreateBackup("/stored/path.sqlite", ("--DBPath", "/override/path.sqlite"));
+            Assert.AreEqual("/override/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(backup));
+        }
+
+        [Test]
+        public void BlankAdvancedDbPathFallsBackToStoredDbPath()
+        {
+            var backup = CreateBackup("/stored/path.sqlite", ("--dbpath", "   "));
+            Assert.AreEqual("/stored/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(backup));
+        }
+    }
+}
diff --git a/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs b/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs
index c0f7a5a9e..3228fba0e 100644
--- a/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs
+++ b/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs
@@ -187,20 +187,24 @@ public class BackupGet : IEndpointV1
 
     private static List<Dictionary<string, object>> ExecuteGetLog(Connection connection, IBackup bk, long? offset, long pagesize)
     {
-        if (!File.Exists(bk.DBPath))
+        // Use the effective database path (honoring a "--dbpath" advanced option) so that the log is
+        // read from the same database the backup actually uses (see issue #1698).
+        var dbpath = Runner.GetEffectiveDBPath(bk);
+        if (!File.Exists(dbpath))
             return new List<Dictionary<string, object>>();
 
-        using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(bk.DBPath))
+        using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(dbpath))
         using (var cmd = con.CreateCommand())
             return LogData.DumpTable(cmd, "LogData", "ID", offset, pagesize);
     }
 
     private static List<Dictionary<string, object>> ExecuteGetRemotelog(Connection connection, IBackup bk, long? offset, long pagesize)
     {
-        if (!File.Exists(bk.DBPath))
+        var dbpath = Runner.GetEffectiveDBPath(bk);
+        if (!File.Exists(dbpath))
             return new List<Dictionary<string, object>>();
 
-        using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(bk.DBPath))
+        using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(dbpath))
         using (var cmd = con.CreateCommand())
         {
             var dt = LogData.DumpTable(cmd, "RemoteOperation", "ID", offset, pagesize);
diff --git a/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupPost.cs b/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupPost.cs
index c95cf956f..faa64b78c 100644
--- a/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupPost.cs
+++ b/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupPost.cs
@@ -105,7 +105,9 @@ public class BackupPost : IEndpointV1
         => connection.GetBackup(id) ?? throw new NotFoundException("Backup not found");
 
     private static void ExecuteDeleteDb(IBackup backup)
-        => File.Delete(backup.DBPath);
+        // Delete the effective database (honoring a "--dbpath" advanced option) so the database the
+        // backup actually uses is removed, not a stale DBPath that may not exist (see issue #1698).
+        => File.Delete(Runner.GetEffectiveDBPath(backup));
 
     private static void UpdateDatabasePath(Connection connection, IBackup backup, string targetpath, bool move)
     {

From 53a768f47b7c7ec91f3552161aaf23b00ff4724a Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Fri, 10 Jul 2026 16:34:14 +0200
Subject: [PATCH 09/19] Removed source check as it failed cross-os

---
 Duplicati/Library/Main/Database/ReusableTransaction.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Duplicati/Library/Main/Database/ReusableTransaction.cs b/Duplicati/Library/Main/Database/ReusableTransaction.cs
index 0372b8d37..b426bdb8c 100644
--- a/Duplicati/Library/Main/Database/ReusableTransaction.cs
+++ b/Duplicati/Library/Main/Database/ReusableTransaction.cs
@@ -153,7 +153,6 @@ internal class ReusableTransaction(SqliteConnection con, SqliteTransaction? tran
     // from other exceptions that might occur during disposal, so we rely on the exception type, source and message.
     private static bool IsInactiveTransactionException(Exception ex)
         => ex is InvalidOperationException
-            && ex.Source == "Microsoft.Data.Sqlite"
             && ex.Message.StartsWith("This SqliteTransaction has completed", StringComparison.Ordinal);
 
     /// <summary>

From 7e31cd5cbad4e1476f5353ac395e9ce0531b8769 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Sat, 11 Jul 2026 06:47:01 +0900
Subject: [PATCH 10/19] Update GitHub Actions to current major versions

Bumps the CI actions to their latest majors to clear the recurring "Node.js 20
is deprecated" warnings (the pinned actions bundled Node 20, which GitHub is
retiring on runners):

- actions/checkout       v4 -> v7
- actions/setup-dotnet   v4 -> v5
- actions/upload-artifact v4 -> v7
- actions/setup-node     v4 -> v6
- actions/stale          v9 -> v10

atomicjar/testcontainers-cloud-setup-action is already on the latest major (v1).

Only the action version tags change. All bumped majors run on Node.js 24 and
require Actions Runner >= v2.327.1, which the GitHub-hosted runners used here
always satisfy. checkout v7's fork-PR checkout block only applies to
pull_request_target/workflow_run (not used here), and setup-node's auto-cache
only triggers with a packageManager field in package.json (not present), so
behavior is unchanged. Validated with actionlint.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/backendtests.yml        | 72 +++++++++++------------
 .github/workflows/build-packages.yml      |  6 +-
 .github/workflows/secretprovidertests.yml | 24 ++++----
 .github/workflows/stale.yml               |  2 +-
 .github/workflows/tests.yml               | 18 +++---
 5 files changed, 61 insertions(+), 61 deletions(-)

diff --git a/.github/workflows/backendtests.yml b/.github/workflows/backendtests.yml
index 7591a0a8f..52ae0ec5a 100644
--- a/.github/workflows/backendtests.yml
+++ b/.github/workflows/backendtests.yml
@@ -269,11 +269,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -309,11 +309,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -347,11 +347,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -386,11 +386,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -424,11 +424,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -463,11 +463,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -500,11 +500,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -540,11 +540,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -579,11 +579,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -613,11 +613,11 @@ jobs:
           - ubuntu-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -646,11 +646,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -684,11 +684,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -720,11 +720,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -758,11 +758,11 @@ jobs:
   #         - macos-latest
   #   steps:
   #     - name: Set up .NET
-  #       uses: actions/setup-dotnet@v4
+  #       uses: actions/setup-dotnet@v5
   #       with:
   #         dotnet-version: 10.x
   #     - name: Checkout source
-  #       uses: actions/checkout@v4
+  #       uses: actions/checkout@v7
   #     - name: Restore NuGet dependencies
   #       run: >-
   #         dotnet restore
@@ -794,11 +794,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -831,11 +831,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -869,11 +869,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -910,11 +910,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
diff --git a/.github/workflows/build-packages.yml b/.github/workflows/build-packages.yml
index cd31002db..294c876d3 100644
--- a/.github/workflows/build-packages.yml
+++ b/.github/workflows/build-packages.yml
@@ -19,12 +19,12 @@ jobs:
 
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
 
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Create dummy changelog file
         working-directory: ./ReleaseBuilder
@@ -41,6 +41,6 @@ jobs:
   # selenium:
   #   runs-on: ubuntu-latest
   #   steps:
-  #     - uses: actions/checkout@v4
+  #     - uses: actions/checkout@v7
   #     - name: Selenium
   #       run: pipeline/selenium/test.sh
diff --git a/.github/workflows/secretprovidertests.yml b/.github/workflows/secretprovidertests.yml
index a0cdcf7b2..119358752 100644
--- a/.github/workflows/secretprovidertests.yml
+++ b/.github/workflows/secretprovidertests.yml
@@ -89,11 +89,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -122,11 +122,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -157,11 +157,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -192,11 +192,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -227,11 +227,11 @@ jobs:
           - macos-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
@@ -252,11 +252,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
       - name: Restore NuGet dependencies
         run: >-
           dotnet restore
diff --git a/.github/workflows/stale.yml b/.github/workflows/stale.yml
index 0ec48e7d0..567da4972 100644
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -15,7 +15,7 @@ jobs:
       issues: write
       actions: write
     steps:
-      - uses: actions/stale@v9
+      - uses: actions/stale@v10
         with:
           days-before-issue-stale: 15
           days-before-issue-close: 15
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 19edc83c2..1daecfc32 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -19,12 +19,12 @@ jobs:
 
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
 
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Restore NuGet dependencies
         run: dotnet restore Duplicati.slnx
@@ -49,12 +49,12 @@ jobs:
 
     steps:
       - name: Set up .NET
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
 
       - name: Checkout source
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Restore NuGet dependencies
         run: dotnet restore Duplicati.slnx
@@ -71,13 +71,13 @@ jobs:
     name: Playwright UI tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-dotnet@v4
+      - uses: actions/setup-dotnet@v5
         with:
           dotnet-version: 10.x
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@v6
         with:
           node-version: 20
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - name: Install NPM dependencies
         run: npm ci
       - name: Install Playwright browsers
@@ -112,7 +112,7 @@ jobs:
 
       - name: Upload Playwright test results on failure
         if: failure()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: playwright-test-results
           path: |
@@ -123,7 +123,7 @@ jobs:
 
       - name: Upload Playwright HTML report
         if: always()
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: playwright-html-report
           path: playwright-report/

From e772a800d495d4edda674e2209813d29ab6ac657 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Sat, 11 Jul 2026 07:31:05 +0900
Subject: [PATCH 11/19] Fix flaky temp-file name collision in debug builds

TempFile.GenerateUniqueName (DEBUG only) builds each name from the caller, a
second-precision timestamp, and the first 8 characters of a Guid, then adds it
to a static tracking dictionary. When many temp files are created within the
same second by the same caller (e.g. BorderTests.Run10kTzstdCompressionAsync,
which writes ~10k blocks), the 8-char Guid prefix can collide, so the generated
name repeats: Dictionary.Add throws "An item with the same key has already been
added", and two TempFiles would otherwise share the same path. Release builds
are unaffected (full Guid, no dictionary).

Append a process-wide atomic counter to the generated name so it is always
unique regardless of timestamp granularity or Guid-prefix collisions. Expose
GenerateUniqueName as internal (Library.Utility already grants InternalsVisibleTo
to the unit-test project) and add a concurrency stress test asserting the
generated names never throw and are all unique.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 Duplicati/Library/Utility/TempFile.cs         | 20 +++--
 Duplicati/UnitTest/TempFileUniqueNameTests.cs | 82 +++++++++++++++++++
 2 files changed, 97 insertions(+), 5 deletions(-)
 create mode 100644 Duplicati/UnitTest/TempFileUniqueNameTests.cs

diff --git a/Duplicati/Library/Utility/TempFile.cs b/Duplicati/Library/Utility/TempFile.cs
index e1e2af6ab..dd70edf1b 100644
--- a/Duplicati/Library/Utility/TempFile.cs
+++ b/Duplicati/Library/Utility/TempFile.cs
@@ -44,6 +44,13 @@ namespace Duplicati.Library.Utility
         private static readonly object m_lock = new object();
         private static readonly Dictionary<string, System.Diagnostics.StackTrace> m_fileTrace = new Dictionary<string, System.Diagnostics.StackTrace>();
 
+        // Process-wide monotonic counter appended to each generated name to guarantee
+        // uniqueness. The timestamp is only second-precision and the Guid is truncated to
+        // 8 characters, so under load (many temp files created in the same second by the
+        // same caller) those alone can collide, which would produce duplicate file paths
+        // and throw from the m_fileTrace.Add below.
+        private static long m_uniqueCounter;
+
         public static System.Diagnostics.StackTrace GetStackTraceForTempFile(string filename)
         {
             lock (m_lock)
@@ -53,17 +60,20 @@ namespace Duplicati.Library.Utility
                     return null;
         }
 
-        private static string GenerateUniqueName()
+        internal static string GenerateUniqueName()
         {
+            // The trailing sequence number guarantees a unique name even when the caller,
+            // second-precision timestamp, and truncated Guid all coincide.
+            var seq = System.Threading.Interlocked.Increment(ref m_uniqueCounter);
             var st = new System.Diagnostics.StackTrace();
             foreach (var f in st.GetFrames())
             {
                 var asm = f.GetMethod()?.DeclaringType?.Assembly;
                 if (asm != null && asm != typeof(TempFile).Assembly)
                 {
-                    var n = string.Format("{0}_{1}_{2}_{3}", f.GetMethod().DeclaringType.FullName, f.GetMethod().Name, Library.Utility.Utility.SerializeDateTime(DateTime.UtcNow), Guid.NewGuid().ToString().Substring(0, 8));
+                    var n = string.Format("{0}_{1}_{2}_{3}_{4}", f.GetMethod().DeclaringType.FullName, f.GetMethod().Name, Library.Utility.Utility.SerializeDateTime(DateTime.UtcNow), Guid.NewGuid().ToString().Substring(0, 8), seq);
                     if (n.IndexOfAny(System.IO.Path.GetInvalidFileNameChars()) >= 0)
-                        n = string.Format("{0}_{1}_{2}_{3}", f.GetMethod().DeclaringType.Name, f.GetMethod().Name, Library.Utility.Utility.SerializeDateTime(DateTime.UtcNow), Guid.NewGuid().ToString().Substring(0, 8));
+                        n = string.Format("{0}_{1}_{2}_{3}_{4}", f.GetMethod().DeclaringType.Name, f.GetMethod().Name, Library.Utility.Utility.SerializeDateTime(DateTime.UtcNow), Guid.NewGuid().ToString().Substring(0, 8), seq);
                     if (n.IndexOfAny(System.IO.Path.GetInvalidFileNameChars()) < 0)
                     {
                         lock (m_lock)
@@ -73,13 +83,13 @@ namespace Duplicati.Library.Utility
                 }
             }
 
-            var s = Guid.NewGuid().ToString();
+            var s = string.Format("{0}_{1}", Guid.NewGuid(), seq);
             lock (m_lock)
                 m_fileTrace.Add(s, st);
             return s;
         }
 #else
-        private static string GenerateUniqueName()
+        internal static string GenerateUniqueName()
         {
             return APPLICATION_PREFIX + Guid.NewGuid().ToString();
         }
diff --git a/Duplicati/UnitTest/TempFileUniqueNameTests.cs b/Duplicati/UnitTest/TempFileUniqueNameTests.cs
new file mode 100644
index 000000000..cf5430fd8
--- /dev/null
+++ b/Duplicati/UnitTest/TempFileUniqueNameTests.cs
@@ -0,0 +1,82 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Duplicati.Library.Utility;
+using NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Duplicati.UnitTest
+{
+    /// <summary>
+    /// Regression tests for <see cref="TempFile"/> unique-name generation. In DEBUG builds
+    /// the name is built from the caller, a second-precision timestamp and a truncated Guid,
+    /// which could collide when many temp files are created in the same second by the same
+    /// caller — producing duplicate paths and throwing from the internal tracking dictionary.
+    /// The generator now appends a process-wide counter to guarantee uniqueness.
+    /// </summary>
+    public class TempFileUniqueNameTests
+    {
+        [Test]
+        [Category("Utility")]
+        public void GeneratedNamesAreUniqueUnderConcurrentLoad()
+        {
+            const int threads = 8;
+            const int perThread = 12500;
+            const int expected = threads * perThread;
+
+            var names = new ConcurrentBag<string>();
+            var errors = new ConcurrentQueue<Exception>();
+
+            var work = new Task[threads];
+            for (var t = 0; t < threads; t++)
+            {
+                work[t] = Task.Run(() =>
+                {
+                    try
+                    {
+                        for (var i = 0; i < perThread; i++)
+                            names.Add(TempFile.GenerateUniqueName());
+                    }
+                    catch (Exception ex)
+                    {
+                        // Before the fix, a name collision throws ArgumentException from the
+                        // tracking dictionary's Add; capture it rather than faulting the task.
+                        errors.Enqueue(ex);
+                    }
+                });
+            }
+
+            Task.WaitAll(work);
+
+            Assert.IsEmpty(errors, "Generating unique temp names must not throw: " + (errors.IsEmpty ? "" : errors.ToArray()[0].ToString()));
+
+            var all = names.ToArray();
+            Assert.AreEqual(expected, all.Length, "Every generation should have produced a name");
+
+            var distinct = new HashSet<string>(all, StringComparer.Ordinal);
+            Assert.AreEqual(all.Length, distinct.Count, "Generated temp file names must all be unique");
+        }
+    }
+}

From f690297d1b03fef9f4e0bd42c8f074b1d31bddff Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Sat, 11 Jul 2026 12:11:30 +0200
Subject: [PATCH 12/19] Server database lock

This PR adds a new locking service that keeps track of which local databases are currently in use by the server. If a database is in use due to a running task, immediate calls will now be rejected.

Prior to this change, immediate calls could interfere with the running task, causing a backup to fail abruptly if the user attempted to check the logs or restore.
---
 .../Library/Interface/CustomExceptions.cs     |  31 +++
 .../Abstractions/IQueueRunnerService.cs       |  26 +-
 Duplicati/Library/RestAPI/Runner.cs           |  43 ++++
 .../Library/SQLiteHelper/SQLiteLoader.cs      |   9 +-
 .../UnitTest/DatabaseLockTrackerTests.cs      | 225 ++++++++++++++++++
 .../UnitTest/FolderStatusServiceTests.cs      |   1 +
 Duplicati/UnitTest/Issue1698.cs               |  96 ++++++++
 .../Abstractions/IDatabaseLockTracker.cs      |  48 ++++
 .../Endpoints/V1/Backup/BackupGet.cs          |  54 +++--
 .../ServiceCollectionsExtensions.cs           |   1 +
 .../Services/DatabaseLockTracker.cs           | 103 ++++++++
 .../Services/QueueRunnerService.cs            |  78 +++++-
 .../Services/TaskQueueService.cs              |   2 +
 13 files changed, 691 insertions(+), 26 deletions(-)
 create mode 100644 Duplicati/UnitTest/DatabaseLockTrackerTests.cs
 create mode 100644 Duplicati/WebserverCore/Abstractions/IDatabaseLockTracker.cs
 create mode 100644 Duplicati/WebserverCore/Services/DatabaseLockTracker.cs

diff --git a/Duplicati/Library/Interface/CustomExceptions.cs b/Duplicati/Library/Interface/CustomExceptions.cs
index a67496de3..0d7f6e55d 100644
--- a/Duplicati/Library/Interface/CustomExceptions.cs
+++ b/Duplicati/Library/Interface/CustomExceptions.cs
@@ -273,4 +273,35 @@ namespace Duplicati.Library.Interface
             : base(message, helpId, innerException)
         { }
     }
+
+    /// <summary>
+    /// Exception indicating that the backup database is currently locked by another running operation
+    /// and cannot be accessed concurrently.
+    /// </summary>
+    [Serializable]
+    public class DatabaseLockedException : UserInformationException
+    {
+        /// <summary>
+        /// The path to the database file that is locked.
+        /// </summary>
+        public readonly string DatabasePath;
+
+        public DatabaseLockedException(string databasePath)
+            : base(LC.L($"The backup database is currently in use by another operation and cannot be accessed concurrently. Please wait for the running operation to finish and try again."), "DatabaseLocked")
+        {
+            DatabasePath = databasePath;
+        }
+
+        public DatabaseLockedException(string databasePath, Exception innerException)
+            : base(LC.L($"The backup database is currently in use by another operation and cannot be accessed concurrently. Please wait for the running operation to finish and try again."), "DatabaseLocked", innerException)
+        {
+            DatabasePath = databasePath;
+        }
+
+        public DatabaseLockedException(string message, string helpId, Exception innerException)
+            : base(message, helpId, innerException)
+        {
+            DatabasePath = string.Empty;
+        }
+    }
 }
diff --git a/Duplicati/Library/RestAPI/Abstractions/IQueueRunnerService.cs b/Duplicati/Library/RestAPI/Abstractions/IQueueRunnerService.cs
index 98a615683..4fe3797c9 100644
--- a/Duplicati/Library/RestAPI/Abstractions/IQueueRunnerService.cs
+++ b/Duplicati/Library/RestAPI/Abstractions/IQueueRunnerService.cs
@@ -99,10 +99,32 @@ public interface IQueueRunnerService
     /// <returns>A list of tuples containing the task ID and backup ID</returns>
     IList<Tuple<long, string?>> GetQueueWithIds();
 
+    /// <summary>
+    /// Cancels the database lock wait for the currently running task, if its ID matches
+    /// <paramref name="taskID"/> and it is still waiting to acquire the database lock.
+    /// If the task has already acquired the lock and is executing, this has no effect —
+    /// call <see cref="IQueuedTask.AbortAsync"/> or <see cref="IQueuedTask.StopAsync"/>
+    /// to interrupt a running task. This method is intended to be called *before*
+    /// <see cref="IQueuedTask.AbortAsync"/>/<see cref="IQueuedTask.StopAsync"/> so that
+    /// a task blocked on lock acquisition is unblocked rather than left stuck.
+    /// </summary>
+    /// <param name="taskID">The ID of the currently running task whose lock wait should be cancelled.</param>
+    void CancelCurrentTaskLockWait(long taskID);
+
     /// <summary>
     /// Runs a task immediately, bypassing the queue.
-    /// Note that the task will run concurrently with the queue tasks and may cause database lock issues.
+    /// If the task's backup database is already in use by a queued task (e.g. a running backup),
+    /// this method throws <see cref="Duplicati.Library.Interface.DatabaseLockedException"/> immediately
+    /// rather than waiting or causing a concurrent "database is locked" error.
+    /// <para>
+    /// Only tasks that expose a database path via <see cref="Duplicati.Library.RestAPI.Runner.GetEffectiveDBPath"/>
+    /// (i.e. <see cref="Duplicati.Library.RestAPI.IRunnerData"/>-backed tasks) are protected by the
+    /// database lock. In production all tasks are <see cref="Duplicati.Library.RestAPI.IRunnerData"/>
+    /// instances; non-runner <see cref="IQueuedTask"/> implementations (test mocks) return a
+    /// <c>null</c> path and bypass locking.
+    /// </para>
     /// </summary>
     /// <param name="task">The task to run</param>
+    /// <exception cref="Duplicati.Library.Interface.DatabaseLockedException">Thrown when the backup database is already in use.</exception>
     Task<IBasicResults?> RunImmediatelyAsync(IQueuedTask task);
-}
\ No newline at end of file
+}
diff --git a/Duplicati/Library/RestAPI/Runner.cs b/Duplicati/Library/RestAPI/Runner.cs
index 0eeca7139..838291f7f 100644
--- a/Duplicati/Library/RestAPI/Runner.cs
+++ b/Duplicati/Library/RestAPI/Runner.cs
@@ -1412,6 +1412,49 @@ namespace Duplicati.Server
             options["remote-sync-json-config"] = JsonSerializer.Serialize(config, jsonOptions);
         }
 
+        /// <summary>
+        /// Returns the effective local database path for an <see cref="IQueuedTask"/> instance.
+        /// In production, all queued tasks are <see cref="IRunnerData"/> instances created by the
+        /// <c>Runner.Create*</c> factories, so this delegates to
+        /// <see cref="GetEffectiveDBPath(IRunnerData?)"/>. If the task is not an
+        /// <see cref="IRunnerData"/> (only possible in tests with mock <see cref="IQueuedTask"/>
+        /// implementations), the result is <c>null</c>.
+        /// </summary>
+        /// <returns>The effective path, or <c>null</c></returns>
+        public static string? GetEffectiveDBPath(IQueuedTask? runnerData)
+            => GetEffectiveDBPath(runnerData as IRunnerData);
+
+        /// <summary>
+        /// Returns the effective local database path for a <see cref="IRunnerData"/> instance.
+        /// The precedence mirrors <see cref="ApplyOptions"/>: the <c>dbpath</c> extra option takes
+        /// priority, then the backup's <c>--dbpath</c> advanced setting, then the stored
+        /// <see cref="Serialization.Interface.IBackup.DBPath"/>. If <c>no-local-db</c> is set
+        /// (either as an extra option or as a backup advanced setting), the result is <c>null</c>.
+        /// </summary>
+        /// <returns>The effective path, or <c>null</c></returns>
+        public static string? GetEffectiveDBPath(IRunnerData? runnerData)
+        {
+            if (runnerData == null)
+                return null;
+
+            if (runnerData.ExtraOptions != null)
+            {
+                if (runnerData.ExtraOptions.ContainsKey("no-local-db") && Utility.ParseBoolOption(runnerData.ExtraOptions.AsReadOnly(), "no-local-db"))
+                    return null;
+                if (runnerData.ExtraOptions.TryGetValue("dbpath", out var dbpath) && !string.IsNullOrWhiteSpace(dbpath))
+                    return dbpath;
+            }
+
+            if (runnerData.Backup == null)
+                return null;
+
+            var setting = runnerData.Backup.Settings?.FirstOrDefault(s => s.Name.Equals($"--no-local-db", StringComparison.OrdinalIgnoreCase));
+            if (setting != null && Utility.ParseBool(setting.Value, true))
+                return null;
+
+            return GetEffectiveDBPath(runnerData.Backup);
+        }
+
         /// <summary>
         /// Returns the effective local database path for a backup: the "--dbpath" advanced option if
         /// it is set, otherwise the stored <see cref="Serialization.Interface.IBackup.DBPath"/>. This
diff --git a/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs b/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs
index 58d3fd7c8..d7706be03 100644
--- a/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs
+++ b/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs
@@ -42,6 +42,13 @@ namespace Duplicati.Library.SQLiteHelper
         /// </summary>
         private static readonly string LOGTAG = Logging.Log.LogTagFromType(typeof(SQLiteLoader));
 
+        /// <summary>
+        /// The default busy timeout (in milliseconds) applied to every connection opened by
+        /// <see cref="OpenSQLiteFileAsync"/> via the connection string. This is a defense-in-depth
+        /// measure that ensures an active reader does not cause failed commits.
+        /// </summary>
+        private const int DefaultBusyTimeoutMs = 10000;
+
         /// <summary>
         /// Helper method with logic to handle opening a database in possibly encrypted format.
         /// </summary>
@@ -278,7 +285,7 @@ namespace Duplicati.Library.SQLiteHelper
         /// <returns>A task that completes when the file is opened.</returns>
         private static async Task OpenSQLiteFileAsync(Microsoft.Data.Sqlite.SqliteConnection con, string path)
         {
-            con.ConnectionString = $"Data Source={path};Pooling=false";
+            con.ConnectionString = $"Data Source={path};Pooling=false;Busy Timeout={DefaultBusyTimeoutMs}";
             await con.OpenAsync().ConfigureAwait(false);
 
             // Make the file only accessible by the current user, unless opting out
diff --git a/Duplicati/UnitTest/DatabaseLockTrackerTests.cs b/Duplicati/UnitTest/DatabaseLockTrackerTests.cs
new file mode 100644
index 000000000..7f403a48b
--- /dev/null
+++ b/Duplicati/UnitTest/DatabaseLockTrackerTests.cs
@@ -0,0 +1,225 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a 
+// copy of this software and associated documentation files (the "Software"), 
+// to deal in the Software without restriction, including without limitation the rights 
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or 
+// sell copies of the Software, and to permit persons to whom the 
+// Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in 
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+// DEALINGS IN THE SOFTWARE.
+
+#nullable enable
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Duplicati.WebserverCore.Services;
+using NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Duplicati.UnitTest
+{
+    /// <summary>
+    /// Tests for <see cref="DatabaseLockTracker"/>, which coordinates access to local
+    /// backup database files between queued and immediate operations.
+    /// </summary>
+    [TestFixture]
+    public class DatabaseLockTrackerTests
+    {
+        /// <summary>
+        /// A simple value-returning async disposable used in tests.
+        /// </summary>
+        private static async Task DisposeAsync(IAsyncDisposable disposable)
+            => await disposable.DisposeAsync().ConfigureAwait(false);
+
+        [Test]
+        public async Task TryAcquireReturnsLockWhenFree()
+        {
+            var tracker = new DatabaseLockTracker();
+            var handle = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(handle, "TryAcquire should succeed when the database is not locked");
+            await DisposeAsync(handle!);
+        }
+
+        [Test]
+        public async Task TryAcquireReturnsNullWhenAlreadyLocked()
+        {
+            var tracker = new DatabaseLockTracker();
+            var first = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(first, "First TryAcquire should succeed");
+
+            var second = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNull(second, "Second TryAcquire should fail when the database is locked");
+
+            await DisposeAsync(first!);
+        }
+
+        [Test]
+        public async Task AcquireAsyncWaitsForExistingLock()
+        {
+            var tracker = new DatabaseLockTracker();
+            var first = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(first);
+
+            var acquireTask = tracker.AcquireAsync("/tmp/test.sqlite", CancellationToken.None);
+            Assert.IsFalse(acquireTask.IsCompleted, "AcquireAsync should be waiting for the lock");
+
+            await DisposeAsync(first!);
+            var second = await acquireTask;
+            Assert.IsNotNull(second, "AcquireAsync should complete after the lock is released");
+            await DisposeAsync(second);
+        }
+
+        [Test]
+        public async Task ReleaseAllowsSubsequentAcquire()
+        {
+            var tracker = new DatabaseLockTracker();
+            var first = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(first);
+            await DisposeAsync(first!);
+
+            var second = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(second, "TryAcquire should succeed after the lock is released");
+            await DisposeAsync(second!);
+        }
+
+        [Test]
+        public async Task DifferentPathsAreIndependent()
+        {
+            var tracker = new DatabaseLockTracker();
+            var lockA = tracker.TryAcquire("/tmp/a.sqlite");
+            Assert.IsNotNull(lockA);
+
+            var lockB = tracker.TryAcquire("/tmp/b.sqlite");
+            Assert.IsNotNull(lockB, "TryAcquire on a different path should succeed independently");
+
+            await DisposeAsync(lockA!);
+            await DisposeAsync(lockB!);
+        }
+
+        [Test]
+        public async Task AcquireAsyncCancelsWhenTokenFires()
+        {
+            var tracker = new DatabaseLockTracker();
+            var first = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(first);
+
+            using var cts = new CancellationTokenSource();
+            var acquireTask = tracker.AcquireAsync("/tmp/test.sqlite", cts.Token);
+            Assert.IsFalse(acquireTask.IsCompleted);
+
+            cts.Cancel();
+
+            Assert.ThrowsAsync<System.OperationCanceledException>(async () => await acquireTask);
+
+            await DisposeAsync(first!);
+        }
+
+        [Test]
+        public async Task DoubleDisposeIsSafe()
+        {
+            var tracker = new DatabaseLockTracker();
+            var handle = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(handle);
+
+            await DisposeAsync(handle!);
+            await DisposeAsync(handle!);
+
+            var next = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(next, "After double-dispose, the lock should be releasable exactly once");
+            await DisposeAsync(next!);
+        }
+
+        [Test]
+        public async Task TryAcquireOnLockedReleasesCorrectly()
+        {
+            var tracker = new DatabaseLockTracker();
+            var first = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(first);
+
+            var second = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNull(second);
+
+            await DisposeAsync(first!);
+
+            var third = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(third, "After releasing the first lock, TryAcquire should succeed");
+            await DisposeAsync(third!);
+        }
+
+        [Test]
+        public async Task RelativeAndAbsolutePathMapToSameLock()
+        {
+            var tracker = new DatabaseLockTracker();
+            var absolute = tracker.TryAcquire(System.IO.Path.GetFullPath("/tmp/test.sqlite"));
+            Assert.IsNotNull(absolute);
+
+            var relative = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNull(relative, "Path normalization should map relative and absolute paths to the same lock");
+
+            await DisposeAsync(absolute!);
+        }
+
+        [Test]
+        public async Task AcquireAsyncPreservesOrder()
+        {
+            var tracker = new DatabaseLockTracker();
+            var first = tracker.TryAcquire("/tmp/test.sqlite");
+            Assert.IsNotNull(first);
+
+            var order = new System.Collections.Generic.List<int>();
+
+            var t2 = Task.Run(async () =>
+            {
+                await using var h = await tracker.AcquireAsync("/tmp/test.sqlite", CancellationToken.None);
+                order.Add(2);
+            });
+
+            var t3 = Task.Run(async () =>
+            {
+                await using var h = await tracker.AcquireAsync("/tmp/test.sqlite", CancellationToken.None);
+                order.Add(3);
+            });
+
+            await Task.Delay(50);
+            order.Add(1);
+            await DisposeAsync(first!);
+
+            await Task.WhenAll(t2, t3);
+
+            Assert.AreEqual(1, order[0], "First lock holder should complete first");
+        }
+
+        [Test]
+        public void TryAcquireEmptyPathThrows()
+        {
+            var tracker = new DatabaseLockTracker();
+            Assert.Throws<ArgumentException>(() => tracker.TryAcquire(""));
+        }
+
+        [Test]
+        public void TryAcquireWhitespacePathThrows()
+        {
+            var tracker = new DatabaseLockTracker();
+            Assert.Throws<ArgumentException>(() => tracker.TryAcquire("   "));
+        }
+
+        [Test]
+        public void AcquireAsyncEmptyPathThrows()
+        {
+            var tracker = new DatabaseLockTracker();
+            Assert.ThrowsAsync<ArgumentException>(async () => await tracker.AcquireAsync("", CancellationToken.None));
+        }
+    }
+}
diff --git a/Duplicati/UnitTest/FolderStatusServiceTests.cs b/Duplicati/UnitTest/FolderStatusServiceTests.cs
index ec461c954..b40db298c 100644
--- a/Duplicati/UnitTest/FolderStatusServiceTests.cs
+++ b/Duplicati/UnitTest/FolderStatusServiceTests.cs
@@ -62,6 +62,7 @@ public class FolderStatusServiceTests
         public void Resume() { }
         public void Pause() { }
         public IList<Tuple<long, string?>> GetQueueWithIds() => new List<Tuple<long, string?>>();
+        public void CancelCurrentTaskLockWait(long taskID) { }
         public Task<IBasicResults?> RunImmediatelyAsync(IQueuedTask task) => Task.FromResult<IBasicResults?>(null);
     }
 
diff --git a/Duplicati/UnitTest/Issue1698.cs b/Duplicati/UnitTest/Issue1698.cs
index bb571e04f..307807472 100644
--- a/Duplicati/UnitTest/Issue1698.cs
+++ b/Duplicati/UnitTest/Issue1698.cs
@@ -24,6 +24,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading.Tasks;
 using Duplicati.Server.Database;
 using Duplicati.Server.Serialization.Interface;
 using NUnit.Framework;
@@ -87,5 +88,100 @@ namespace Duplicati.UnitTest
             var backup = CreateBackup("/stored/path.sqlite", ("--dbpath", "   "));
             Assert.AreEqual("/stored/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(backup));
         }
+
+        // ---- Tests for GetEffectiveDBPath(IQueuedTask) / GetEffectiveDBPath(IRunnerData) ----
+
+        private static Duplicati.Server.Runner.IRunnerData CreateRunnerTask(
+            Backup backup,
+            IDictionary<string, string?>? extraOptions = null)
+            => Duplicati.Server.Runner.CreateTask(
+                Duplicati.Server.Serialization.DuplicatiOperation.BackupOrSync,
+                backup,
+                extraOptions ?? new Dictionary<string, string?>());
+
+        [Test]
+        public void RunnerDataFallsBackToBackupDbPath()
+        {
+            var backup = CreateBackup("/stored/path.sqlite");
+            var task = CreateRunnerTask(backup);
+            Assert.AreEqual("/stored/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(task));
+        }
+
+        [Test]
+        public void RunnerDataRespectsBackupAdvancedDbPath()
+        {
+            var backup = CreateBackup("/stored/path.sqlite", ("--dbpath", "/override/path.sqlite"));
+            var task = CreateRunnerTask(backup);
+            Assert.AreEqual("/override/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(task));
+        }
+
+        [Test]
+        public void RunnerDataExtraDbPathOverridesBackup()
+        {
+            var backup = CreateBackup("/stored/path.sqlite", ("--dbpath", "/backup-override.sqlite"));
+            var task = CreateRunnerTask(backup, new Dictionary<string, string?> { ["dbpath"] = "/extra-override.sqlite" });
+            Assert.AreEqual("/extra-override.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(task));
+        }
+
+        [Test]
+        public void RunnerDataExtraNoLocalDbReturnsNull()
+        {
+            var backup = CreateBackup("/stored/path.sqlite");
+            var task = CreateRunnerTask(backup, new Dictionary<string, string?> { ["no-local-db"] = "true" });
+            Assert.IsNull(Duplicati.Server.Runner.GetEffectiveDBPath(task));
+        }
+
+        [Test]
+        public void RunnerDataBackupNoLocalDbSettingReturnsNull()
+        {
+            var backup = CreateBackup("/stored/path.sqlite", ("--no-local-db", "true"));
+            var task = CreateRunnerTask(backup);
+            Assert.IsNull(Duplicati.Server.Runner.GetEffectiveDBPath(task));
+        }
+
+        [Test]
+        public void RunnerDataExtraNoLocalDbFalseReturnsDbPath()
+        {
+            var backup = CreateBackup("/stored/path.sqlite");
+            var task = CreateRunnerTask(backup, new Dictionary<string, string?> { ["no-local-db"] = "false" });
+            Assert.AreEqual("/stored/path.sqlite", Duplicati.Server.Runner.GetEffectiveDBPath(task));
+        }
+
+        [Test]
+        public void RunnerDataNullReturnsNull()
+        {
+            Assert.IsNull(Duplicati.Server.Runner.GetEffectiveDBPath((Duplicati.Server.Runner.IRunnerData?)null));
+            Assert.IsNull(Duplicati.Server.Runner.GetEffectiveDBPath((Duplicati.Server.Serialization.Interface.IQueuedTask?)null));
+        }
+
+        [Test]
+        public void RunnerDataNonRunnerDataQueuedTaskReturnsNull()
+        {
+            // A non-IRunnerData IQueuedTask implementation should cast to null and return null.
+            var nonRunnerTask = new NonRunnerQueuedTask();
+            Assert.IsNull(Duplicati.Server.Runner.GetEffectiveDBPath(nonRunnerTask));
+        }
+
+        /// <summary>
+        /// A minimal <see cref="IQueuedTask"/> implementation that is NOT an
+        /// <see cref="Duplicati.Server.Runner.IRunnerData"/>, used to verify that
+        /// <see cref="Duplicati.Server.Runner.GetEffectiveDBPath(IQueuedTask)"/> safely returns
+        /// null for non-runner tasks.
+        /// </summary>
+        private sealed class NonRunnerQueuedTask : Duplicati.Server.Serialization.Interface.IQueuedTask
+        {
+            public long TaskID => 0;
+            public string? BackupID => null;
+            public Duplicati.Server.Serialization.DuplicatiOperation Operation => Duplicati.Server.Serialization.DuplicatiOperation.BackupOrSync;
+            public Func<Task>? OnStarting { get; set; }
+            public Func<Exception?, Task>? OnFinished { get; set; }
+            public DateTime? TaskStarted { get; set; }
+            public DateTime? TaskFinished { get; set; }
+            public Task UpdateThrottleSpeedsAsync(string? uploadSpeed, string? downloadSpeed) => Task.CompletedTask;
+            public Task StopAsync() => Task.CompletedTask;
+            public Task AbortAsync() => Task.CompletedTask;
+            public Task PauseAsync(bool alsoTransfers) => Task.CompletedTask;
+            public Task ResumeAsync() => Task.CompletedTask;
+        }
     }
 }
diff --git a/Duplicati/WebserverCore/Abstractions/IDatabaseLockTracker.cs b/Duplicati/WebserverCore/Abstractions/IDatabaseLockTracker.cs
new file mode 100644
index 000000000..4637b1d63
--- /dev/null
+++ b/Duplicati/WebserverCore/Abstractions/IDatabaseLockTracker.cs
@@ -0,0 +1,48 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a 
+// copy of this software and associated documentation files (the "Software"), 
+// to deal in the Software without restriction, including without limitation the rights 
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or 
+// sell copies of the Software, and to permit persons to whom the 
+// Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in 
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+// DEALINGS IN THE SOFTWARE.
+
+namespace Duplicati.WebserverCore.Abstractions;
+
+/// <summary>
+/// Tracks which local backup database files are currently in use by running operations,
+/// preventing concurrent access that would cause SQLite "database is locked" errors.
+/// </summary>
+public interface IDatabaseLockTracker
+{
+    /// <summary>
+    /// Attempts to acquire a lock on the given database path, waiting until the lock
+    /// is available. Used by queued tasks (backup, restore, etc.) which should wait
+    /// for any concurrent immediate operations to finish.
+    /// </summary>
+    /// <param name="dbPath">The normalized, full path to the database file.</param>
+    /// <param name="cancellationToken">A cancellation token to cancel the wait.</param>
+    /// <returns>A disposable handle that releases the lock when disposed.</returns>
+    Task<IAsyncDisposable> AcquireAsync(string dbPath, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Attempts to acquire a lock on the given database path, failing immediately if
+    /// the database is already in use. Used by immediate (non-queued) operations such
+    /// as listing filesets from the restore UI.
+    /// </summary>
+    /// <param name="dbPath">The normalized, full path to the database file.</param>
+    /// <returns>A disposable handle that releases the lock when disposed, or <c>null</c> if the database is already locked.</returns>
+    IAsyncDisposable? TryAcquire(string dbPath);
+}
diff --git a/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs b/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs
index 3228fba0e..29c167110 100644
--- a/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs
+++ b/Duplicati/WebserverCore/Endpoints/V1/Backup/BackupGet.cs
@@ -45,12 +45,12 @@ public class BackupGet : IEndpointV1
             => ExecuteGetFilesAsync(queueRunnerService, GetBackup(connection, id), filter, time, allVersions ?? false, prefixOnly ?? false, folderContents ?? false, new Dictionary<string, string>()))
             .RequireAuthorization();
 
-        group.MapGet("/backup/{id}/log", ([FromServices] Connection connection, [FromRoute] string id, [FromQuery] long? offset, [FromQuery] long? pagesize)
-            => ExecuteGetLog(connection, GetBackup(connection, id), offset, pagesize ?? 100))
+        group.MapGet("/backup/{id}/log", ([FromServices] Connection connection, [FromServices] IDatabaseLockTracker databaseLockTracker, [FromRoute] string id, [FromQuery] long? offset, [FromQuery] long? pagesize)
+            => ExecuteGetLog(connection, databaseLockTracker, GetBackup(connection, id), offset, pagesize ?? 100))
             .RequireAuthorization();
 
-        group.MapGet("/backup/{id}/remotelog", ([FromServices] Connection connection, [FromRoute] string id, [FromQuery] long? offset, [FromQuery] long? pagesize)
-            => ExecuteGetRemotelog(connection, GetBackup(connection, id), offset, pagesize ?? 100))
+        group.MapGet("/backup/{id}/remotelog", ([FromServices] Connection connection, [FromServices] IDatabaseLockTracker databaseLockTracker, [FromRoute] string id, [FromQuery] long? offset, [FromQuery] long? pagesize)
+            => ExecuteGetRemotelog(connection, databaseLockTracker, GetBackup(connection, id), offset, pagesize ?? 100))
             .RequireAuthorization();
 
         group.MapGet("/backup/{id}/filesets", ([FromServices] Connection connection, [FromServices] IQueueRunnerService queueRunnerService, [FromRoute] string id, [FromQuery(Name = "include-metadata")] bool? includeMetadata, [FromQuery(Name = "from-remote-only")] bool? fromRemoteOnly)
@@ -185,7 +185,7 @@ public class BackupGet : IEndpointV1
     private static async Task<Dictionary<string, object>> ExecuteGetFilesAsync(IQueueRunnerService queueRunnerService, IBackup bk, string? filter, string? timestring, bool allVersions, bool prefixOnly, bool folderContents, Dictionary<string, string> extraValues)
         => await SearchFilesAsync(queueRunnerService, bk, filter, timestring, allVersions, prefixOnly, folderContents, extraValues).ConfigureAwait(false);
 
-    private static List<Dictionary<string, object>> ExecuteGetLog(Connection connection, IBackup bk, long? offset, long pagesize)
+    private static async Task<List<Dictionary<string, object>>> ExecuteGetLog(Connection connection, IDatabaseLockTracker databaseLockTracker, IBackup bk, long? offset, long pagesize)
     {
         // Use the effective database path (honoring a "--dbpath" advanced option) so that the log is
         // read from the same database the backup actually uses (see issue #1698).
@@ -193,28 +193,48 @@ public class BackupGet : IEndpointV1
         if (!File.Exists(dbpath))
             return new List<Dictionary<string, object>>();
 
-        using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(dbpath))
-        using (var cmd = con.CreateCommand())
-            return LogData.DumpTable(cmd, "LogData", "ID", offset, pagesize);
+        var dbLock = databaseLockTracker.TryAcquire(dbpath)
+            ?? throw new DatabaseLockedException(dbpath);
+
+        try
+        {
+            using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(dbpath))
+            using (var cmd = con.CreateCommand())
+                return LogData.DumpTable(cmd, "LogData", "ID", offset, pagesize);
+        }
+        finally
+        {
+            await dbLock.DisposeAsync().ConfigureAwait(false);
+        }
     }
 
-    private static List<Dictionary<string, object>> ExecuteGetRemotelog(Connection connection, IBackup bk, long? offset, long pagesize)
+    private static async Task<List<Dictionary<string, object>>> ExecuteGetRemotelog(Connection connection, IDatabaseLockTracker databaseLockTracker, IBackup bk, long? offset, long pagesize)
     {
         var dbpath = Runner.GetEffectiveDBPath(bk);
         if (!File.Exists(dbpath))
             return new List<Dictionary<string, object>>();
 
-        using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(dbpath))
-        using (var cmd = con.CreateCommand())
+        var dbLock = databaseLockTracker.TryAcquire(dbpath)
+            ?? throw new DatabaseLockedException(dbpath);
+
+        try
         {
-            var dt = LogData.DumpTable(cmd, "RemoteOperation", "ID", offset, pagesize);
+            using (var con = Library.SQLiteHelper.SQLiteLoader.LoadConnection(dbpath))
+            using (var cmd = con.CreateCommand())
+            {
+                var dt = LogData.DumpTable(cmd, "RemoteOperation", "ID", offset, pagesize);
 
-            // Unwrap raw data to a string
-            foreach (var n in dt)
-                try { n["Data"] = System.Text.Encoding.UTF8.GetString((byte[])n["Data"]); }
-                catch { }
+                // Unwrap raw data to a string
+                foreach (var n in dt)
+                    try { n["Data"] = System.Text.Encoding.UTF8.GetString((byte[])n["Data"]); }
+                    catch { }
 
-            return dt;
+                return dt;
+            }
+        }
+        finally
+        {
+            await dbLock.DisposeAsync().ConfigureAwait(false);
         }
     }
 
diff --git a/Duplicati/WebserverCore/Extensions/ServiceCollectionsExtensions.cs b/Duplicati/WebserverCore/Extensions/ServiceCollectionsExtensions.cs
index b10255e9f..5ade6e3ef 100644
--- a/Duplicati/WebserverCore/Extensions/ServiceCollectionsExtensions.cs
+++ b/Duplicati/WebserverCore/Extensions/ServiceCollectionsExtensions.cs
@@ -67,6 +67,7 @@ public static class ServiceCollectionsExtensions
             .AddSingleton<IRemoteControllerRegistration, RemoteControllerRegistrationService>()
             .AddSingleton<ISystemInfoProvider, SystemInfoProvider>()
             .AddSingleton<IQueueRunnerService, QueueRunnerService>()
+            .AddSingleton<IDatabaseLockTracker, DatabaseLockTracker>()
             .AddSingleton<IProgressStateProviderService, ProgressStateProviderService>()
             .AddTransient<INotificationService, NotificationService>()
             .AddTransient<IBackupListService, BackupListService>()
diff --git a/Duplicati/WebserverCore/Services/DatabaseLockTracker.cs b/Duplicati/WebserverCore/Services/DatabaseLockTracker.cs
new file mode 100644
index 000000000..935bb3c3b
--- /dev/null
+++ b/Duplicati/WebserverCore/Services/DatabaseLockTracker.cs
@@ -0,0 +1,103 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a 
+// copy of this software and associated documentation files (the "Software"), 
+// to deal in the Software without restriction, including without limitation the rights 
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or 
+// sell copies of the Software, and to permit persons to whom the 
+// Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in 
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
+// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+// DEALINGS IN THE SOFTWARE.
+
+using System.Collections.Concurrent;
+using Duplicati.WebserverCore.Abstractions;
+
+namespace Duplicati.WebserverCore.Services;
+
+/// <summary>
+/// Tracks which local backup database files are currently in use by running operations,
+/// preventing concurrent access that would cause SQLite "database is locked" errors.
+/// </summary>
+/// <remarks>
+/// Each database path gets its own <see cref="SemaphoreSlim"/> (initial count 1).
+/// Queued tasks call <see cref="AcquireAsync"/> which waits for the lock.
+/// Immediate tasks call <see cref="TryAcquire"/> which fails instantly if locked.
+/// <para>
+/// Semaphore entries are intentionally not removed on release. Removing them is racy: a
+/// concurrent acquirer could take the lock between a release and a dictionary removal,
+/// after which a new acquirer would create a fresh semaphore for the same path, breaking
+/// mutual exclusion. The dictionary is bounded by the number of unique database paths
+/// (one per backup), which is a small, long-lived set, so the lack of cleanup does not
+/// cause unbounded growth in practice.
+/// </para>
+/// </remarks>
+public class DatabaseLockTracker : IDatabaseLockTracker
+{
+    private const int MaxLockCount = 1;
+
+    private readonly ConcurrentDictionary<string, SemaphoreSlim> _locks = new(Library.Utility.Utility.ClientFilenameStringComparer);
+
+    /// <inheritdoc />
+    public async Task<IAsyncDisposable> AcquireAsync(string dbPath, CancellationToken cancellationToken)
+    {
+        var semaphore = GetOrCreateSemaphore(dbPath);
+        await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+        return new LockRelease(semaphore);
+    }
+
+    /// <inheritdoc />
+    public IAsyncDisposable? TryAcquire(string dbPath)
+    {
+        var semaphore = GetOrCreateSemaphore(dbPath);
+        if (!semaphore.Wait(0))
+            return null;
+        return new LockRelease(semaphore);
+    }
+
+    /// <summary>
+    /// Normalizes the database path and gets (or creates) the semaphore for it.
+    /// </summary>
+    private SemaphoreSlim GetOrCreateSemaphore(string dbPath)
+    {
+        var normalized = NormalizePath(dbPath);
+        if (string.IsNullOrEmpty(normalized))
+            throw new ArgumentException("Database path cannot be null or empty", nameof(dbPath));
+        return _locks.GetOrAdd(normalized, _ => new SemaphoreSlim(MaxLockCount, MaxLockCount));
+    }
+
+    /// <summary>
+    /// Normalizes a file path so that the same database file always maps to the same key,
+    /// regardless of path separators or relative vs. absolute forms.
+    /// </summary>
+    private static string NormalizePath(string dbPath)
+    {
+        if (string.IsNullOrWhiteSpace(dbPath))
+            return string.Empty;
+        return Path.GetFullPath(dbPath);
+    }
+
+    /// <summary>
+    /// A disposable handle that releases the semaphore when disposed.
+    /// </summary>
+    private sealed class LockRelease(SemaphoreSlim semaphore) : IAsyncDisposable
+    {
+        private int _released;
+
+        public ValueTask DisposeAsync()
+        {
+            if (Interlocked.Exchange(ref _released, 1) == 0)
+                semaphore.Release();
+            return ValueTask.CompletedTask;
+        }
+    }
+}
diff --git a/Duplicati/WebserverCore/Services/QueueRunnerService.cs b/Duplicati/WebserverCore/Services/QueueRunnerService.cs
index 7d4b860d2..b89b23272 100644
--- a/Duplicati/WebserverCore/Services/QueueRunnerService.cs
+++ b/Duplicati/WebserverCore/Services/QueueRunnerService.cs
@@ -37,7 +37,8 @@ public class QueueRunnerService(
     EventPollNotify eventPollNotify,
     INotificationUpdateService notificationUpdateService,
     IProgressStateProviderService progressStateProviderService,
-    IApplicationSettings applicationSettings) : IQueueRunnerService
+    IApplicationSettings applicationSettings,
+    IDatabaseLockTracker databaseLockTracker) : IQueueRunnerService, IDisposable
 {
     private readonly object _lock = new();
     /// <summary>
@@ -51,9 +52,10 @@ public class QueueRunnerService(
     private static readonly int MAX_TASK_RESULT_CACHE_SIZE = 100;
 
     private readonly List<IQueuedTask> _tasks = new();
-    private (Task? Task, IQueuedTask? QueuedTask) _current;
+    private (Task? Task, IQueuedTask? QueuedTask, CancellationTokenSource? LockCts) _current;
     private bool _isPaused;
     private bool _isTerminated;
+    private readonly CancellationTokenSource _terminateCts = new();
 
     public long AddTask(IQueuedTask task)
         => AddTask(task, false);
@@ -101,6 +103,7 @@ public class QueueRunnerService(
     public void Terminate(bool wait)
     {
         _isTerminated = true;
+        _terminateCts.Cancel();
         if (wait)
         {
             var task = _current.Task;
@@ -118,20 +121,27 @@ public class QueueRunnerService(
 
             // Clean up completed tasks
             if (_current.Task != null && _current.Task.IsCompleted)
-                _current = (null, null);
+            {
+                _current.LockCts?.Dispose();
+                _current = (null, null, null);
+            }
 
             if (_tasks.Count == 0)
                 return;
 
             var nextTask = _tasks[0];
             _tasks.RemoveAt(0);
-            _current = (Task.Run(() => RunTaskAsync(nextTask), CancellationToken.None), nextTask);
+            _current = (Task.Run(() => RunTaskAsync(nextTask), CancellationToken.None), nextTask, null);
         }
     }
 
     private async Task RunTaskAsync(IQueuedTask task)
     {
         var completed = false;
+        IAsyncDisposable? dbLock = null;
+        var lockCts = CancellationTokenSource.CreateLinkedTokenSource(_terminateCts.Token);
+        lock (_lock)
+            _current = (_current.Task, _current.QueuedTask, lockCts);
         try
         {
             eventPollNotify.SignalNewEvent();
@@ -140,6 +150,8 @@ public class QueueRunnerService(
             if (task.OnStarting != null)
                 await task.OnStarting().ConfigureAwait(false);
 
+            dbLock = await AcquireDatabaseLockAsync(task, lockCts.Token).ConfigureAwait(false);
+
             await Runner.RunAsync(connection, eventPollNotify, notificationUpdateService, progressStateProviderService, applicationSettings, task, true).ConfigureAwait(false);
 
             // If the task is completed, don't call OnFinished again
@@ -160,9 +172,14 @@ public class QueueRunnerService(
         }
         finally
         {
+            if (dbLock != null)
+                await dbLock.DisposeAsync().ConfigureAwait(false);
             task.TaskFinished = DateTime.UtcNow;
             lock (_lock)
-                _current = (null, null);
+            {
+                lockCts.Dispose();
+                _current = (null, null, null);
+            }
             eventPollNotify.SignalNewEvent();
             eventPollNotify.SignalTaskQueueUpdate();
             eventPollNotify.SignalTaskCompleted(task.TaskID);
@@ -215,6 +232,55 @@ public class QueueRunnerService(
     /// <inheritdoc/>
     public async Task<IBasicResults?> RunImmediatelyAsync(IQueuedTask task)
     {
-        return await Runner.RunAsync(connection, eventPollNotify, notificationUpdateService, progressStateProviderService, applicationSettings, task, false).ConfigureAwait(false);
+        IAsyncDisposable? dbLock = null;
+        var dbPath = Runner.GetEffectiveDBPath(task);
+
+        // If we have a database to work with, make sure we can get the lock
+        if (!string.IsNullOrWhiteSpace(dbPath))
+            dbLock = databaseLockTracker.TryAcquire(dbPath)
+                ?? throw new DatabaseLockedException(dbPath);
+
+        try
+        {
+            return await Runner.RunAsync(connection, eventPollNotify, notificationUpdateService, progressStateProviderService, applicationSettings, task, false).ConfigureAwait(false);
+        }
+        finally
+        {
+            if (dbLock != null)
+                await dbLock.DisposeAsync().ConfigureAwait(false);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void CancelCurrentTaskLockWait(long taskID)
+    {
+        lock (_lock)
+        {
+            if (_current.QueuedTask?.TaskID == taskID && _current.LockCts != null)
+                _current.LockCts.Cancel();
+        }
+    }
+
+    /// <summary>
+    /// Acquires the database lock for a queued task, waiting until the lock is available
+    /// or the cancellation token is cancelled. Tasks without a database path (e.g. custom
+    /// runner tasks) skip locking.
+    /// </summary>
+    private async Task<IAsyncDisposable?> AcquireDatabaseLockAsync(IQueuedTask task, CancellationToken cancellationToken)
+    {
+        var dbPath = Runner.GetEffectiveDBPath(task);
+        if (string.IsNullOrWhiteSpace(dbPath))
+            return null;
+
+        return await databaseLockTracker.AcquireAsync(dbPath, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <summary>
+    /// Disposes resources held by the queue runner, including the termination
+    /// cancellation token source used to cancel tasks waiting on the database lock.
+    /// </summary>
+    public void Dispose()
+    {
+        _terminateCts.Dispose();
     }
 }
\ No newline at end of file
diff --git a/Duplicati/WebserverCore/Services/TaskQueueService.cs b/Duplicati/WebserverCore/Services/TaskQueueService.cs
index 3616ea2a2..3f36d0cb4 100644
--- a/Duplicati/WebserverCore/Services/TaskQueueService.cs
+++ b/Duplicati/WebserverCore/Services/TaskQueueService.cs
@@ -108,6 +108,8 @@ public class TaskQueueService(IQueueRunnerService queueRunnerService) : ITaskQue
         if (task == null)
             throw new NotFoundException("No such task found");
 
+        queueRunnerService.CancelCurrentTaskLockWait(task.TaskID);
+
         if (abort)
             await task.AbortAsync().ConfigureAwait(false);
         else

From 36da653eb27224f3408bdd5b2fc388cabbc73874 Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Sat, 11 Jul 2026 12:17:42 +0200
Subject: [PATCH 13/19] Improve metadata update

This PR updates the logic for metadata update after an operation has completed, such that the data displayed in the UI is more consistent with the remote storage situation.
---
 Duplicati/Library/Interface/ResultInterfaces.cs |  4 ++--
 Duplicati/Library/Main/IPC/Dto/ResultsDto.cs    |  6 +++++-
 Duplicati/Library/Main/IPC/ResultWrappers.cs    |  4 ++++
 Duplicati/Library/RestAPI/Runner.cs             | 12 +++++++++++-
 4 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/Duplicati/Library/Interface/ResultInterfaces.cs b/Duplicati/Library/Interface/ResultInterfaces.cs
index ecf26ea17..cdf82b2cf 100644
--- a/Duplicati/Library/Interface/ResultInterfaces.cs
+++ b/Duplicati/Library/Interface/ResultInterfaces.cs
@@ -309,7 +309,7 @@ namespace Duplicati.Library.Interface
         IEnumerable<IListResultRemoteVolume> RemoteVolumes { get; }
     }
 
-    public interface IDeleteResults : IBasicResults
+    public interface IDeleteResults : IBasicResults, IBackendStatsticsReporter
     {
         IEnumerable<Tuple<long, DateTime>> DeletedSets { get; }
         ICompactResults CompactResults { get; }
@@ -377,7 +377,7 @@ namespace Duplicati.Library.Interface
         IEnumerable<IFileEntry> Files { get; }
     }
 
-    public interface ICompactResults : IBasicResults, IResultsWithVacuum
+    public interface ICompactResults : IBasicResults, IResultsWithVacuum, IBackendStatsticsReporter
     {
         long DeletedFileCount { get; }
         long DownloadedFileCount { get; }
diff --git a/Duplicati/Library/Main/IPC/Dto/ResultsDto.cs b/Duplicati/Library/Main/IPC/Dto/ResultsDto.cs
index 057fd6111..d4b16032f 100644
--- a/Duplicati/Library/Main/IPC/Dto/ResultsDto.cs
+++ b/Duplicati/Library/Main/IPC/Dto/ResultsDto.cs
@@ -211,6 +211,7 @@ public class CompactResultsDto : BasicResultsDto
     public long UploadedFileSize { get; set; }
     public bool Dryrun { get; set; }
     public VacuumResultsDto VacuumResults { get; set; }
+    public BackendStatisticsDto BackendStatistics { get; set; }
 
     public static CompactResultsDto FromResults(ICompactResults results)
     {
@@ -232,7 +233,8 @@ public class CompactResultsDto : BasicResultsDto
             DownloadedFileSize = results.DownloadedFileSize,
             UploadedFileSize = results.UploadedFileSize,
             Dryrun = results.Dryrun,
-            VacuumResults = VacuumResultsDto.FromResults(results.VacuumResults)
+            VacuumResults = VacuumResultsDto.FromResults(results.VacuumResults),
+            BackendStatistics = BackendStatisticsDto.FromResults(results.BackendStatistics)
         };
     }
 }
@@ -310,6 +312,7 @@ public class DeleteResultsDto : BasicResultsDto
 {
     public List<Tuple<long, DateTime>> DeletedSets { get; set; } = new();
     public CompactResultsDto CompactResults { get; set; }
+    public BackendStatisticsDto BackendStatistics { get; set; }
     public bool Dryrun { get; set; }
 
     public static DeleteResultsDto FromResults(IDeleteResults results)
@@ -327,6 +330,7 @@ public class DeleteResultsDto : BasicResultsDto
             Interrupted = results.Interrupted,
             DeletedSets = results.DeletedSets?.ToList() ?? new List<Tuple<long, DateTime>>(),
             CompactResults = CompactResultsDto.FromResults(results.CompactResults),
+            BackendStatistics = BackendStatisticsDto.FromResults(results.BackendStatistics),
             Dryrun = results.Dryrun
         };
     }
diff --git a/Duplicati/Library/Main/IPC/ResultWrappers.cs b/Duplicati/Library/Main/IPC/ResultWrappers.cs
index 341d4b878..718830a75 100644
--- a/Duplicati/Library/Main/IPC/ResultWrappers.cs
+++ b/Duplicati/Library/Main/IPC/ResultWrappers.cs
@@ -146,6 +146,8 @@ public class CompactResultsWrapper : BasicResultsWrapper, ICompactResults
         get => _dto.VacuumResults == null ? null : new VacuumResultsWrapper(_dto.VacuumResults);
         set => throw new InvalidOperationException("Cannot set property on wrapper");
     }
+
+    public IBackendStatstics BackendStatistics => _dto.BackendStatistics == null ? null : new BackendStatisticsWrapper(_dto.BackendStatistics);
 }
 
 /// <summary>
@@ -188,6 +190,8 @@ public class DeleteResultsWrapper : BasicResultsWrapper, IDeleteResults
     public IEnumerable<Tuple<long, DateTime>> DeletedSets => _dto.DeletedSets;
     public ICompactResults CompactResults => _dto.CompactResults == null ? null : new CompactResultsWrapper(_dto.CompactResults);
     public bool Dryrun => _dto.Dryrun;
+
+    public IBackendStatstics BackendStatistics => _dto.BackendStatistics == null ? null : new BackendStatisticsWrapper(_dto.BackendStatistics);
 }
 
 /// <summary>
diff --git a/Duplicati/Library/RestAPI/Runner.cs b/Duplicati/Library/RestAPI/Runner.cs
index 0eeca7139..b0fedf6c0 100644
--- a/Duplicati/Library/RestAPI/Runner.cs
+++ b/Duplicati/Library/RestAPI/Runner.cs
@@ -1164,7 +1164,7 @@ namespace Duplicati.Server
 
         private static void UpdateMetadataStatistics(IBackup backup, IParsedBackendStatistics r)
         {
-            if (r != null)
+            if (r != null && r.RemoteCalls > 0)
             {
                 backup.Metadata["LastBackupDate"] = Utility.SerializeDateTime(r.LastBackupDate.ToUniversalTime());
                 backup.Metadata["BackupListCount"] = r.BackupListCount.ToString();
@@ -1217,6 +1217,16 @@ namespace Duplicati.Server
                 UpdateMetadataLastSync(backup, r6);
             }
 
+            if (result is IDeleteResults r7)
+            {
+                if (r7.CompactResults != null)
+                {
+                    UpdateMetadataLastCompact(backup, r7.CompactResults);
+                    if (!r7.CompactResults.Interrupted && r7.CompactResults.DeletedFileCount > 0 && r7.CompactResults.BackendStatistics is IParsedBackendStatistics p)
+                        UpdateMetadataStatistics(backup, p);
+                }
+            }
+
             if (result is IBackupResults r)
             {
                 if (!result.Interrupted)

From 824fc76c7229cebc3455b09b945d6fea4ee9b6ac Mon Sep 17 00:00:00 2001
From: Kenneth Skovhede <kenneth@duplicati.com>
Date: Sat, 11 Jul 2026 12:22:28 +0200
Subject: [PATCH 14/19] Switched to pragma for busy_timeout.

---
 Duplicati/Library/SQLiteHelper/SQLiteLoader.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs b/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs
index d7706be03..2898de067 100644
--- a/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs
+++ b/Duplicati/Library/SQLiteHelper/SQLiteLoader.cs
@@ -285,9 +285,15 @@ namespace Duplicati.Library.SQLiteHelper
         /// <returns>A task that completes when the file is opened.</returns>
         private static async Task OpenSQLiteFileAsync(Microsoft.Data.Sqlite.SqliteConnection con, string path)
         {
-            con.ConnectionString = $"Data Source={path};Pooling=false;Busy Timeout={DefaultBusyTimeoutMs}";
+            con.ConnectionString = $"Data Source={path};Pooling=false";
             await con.OpenAsync().ConfigureAwait(false);
 
+            using (var cmd = con.CreateCommand())
+            {
+                cmd.CommandText = $"PRAGMA busy_timeout={DefaultBusyTimeoutMs}";
+                await cmd.ExecuteNonQueryAsync().ConfigureAwait(false);
+            }
+
             // Make the file only accessible by the current user, unless opting out
             if (!SystemIO.IO_OS.FileExists(SystemIO.IO_OS.PathCombine(SystemIO.IO_OS.PathGetDirectoryName(path), Util.InsecurePermissionsMarkerFile)))
                 try { SystemIO.IO_OS.FileSetPermissionUserRWOnly(path); }

From e0d9848d0eaf28f3118e851862ea5b42cc457a33 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Sat, 11 Jul 2026 21:50:01 +0900
Subject: [PATCH 15/19] Fix test-filters ignoring --source from a parameters
 file (#4812)

When running `test-filters --parameters-file=...`, the parameters file's
--source entries were dropped and its --target was injected as the (only)
positional path, so filter testing ran against the backend URL instead of the
real source paths. The parameters-file handling only appended --source for the
`backup` command and always treated the first positional argument as a target.

test-filters/test-filter take source paths as positional arguments and have no
target, so the handling now appends --source for those commands (as it does for
backup) and does not inject --target (reported at verbose level, consistent with
how a --source on a non-backup command is already handled).

Adds an Issue4812 regression test driving Program.RunCommandLine.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 Duplicati/CommandLine/CLI/Program.cs | 14 ++++-
 Duplicati/CommandLine/CLI/Strings.cs |  1 +
 Duplicati/UnitTest/Issue4812.cs      | 83 ++++++++++++++++++++++++++++
 3 files changed, 96 insertions(+), 2 deletions(-)
 create mode 100644 Duplicati/UnitTest/Issue4812.cs

diff --git a/Duplicati/CommandLine/CLI/Program.cs b/Duplicati/CommandLine/CLI/Program.cs
index 1a2f0150b..59b36a95d 100644
--- a/Duplicati/CommandLine/CLI/Program.cs
+++ b/Duplicati/CommandLine/CLI/Program.cs
@@ -393,15 +393,25 @@ namespace Duplicati.CommandLine
                 foreach (KeyValuePair<String, String> keyvalue in opt)
                     options[keyvalue.Key] = keyvalue.Value;
 
+                var command = cargs.Count >= 1 ? cargs[0] : string.Empty;
+                var isBackup = command.Equals("backup", StringComparison.OrdinalIgnoreCase);
+                var isTestFilters = command.Equals("test-filters", StringComparison.OrdinalIgnoreCase)
+                                 || command.Equals("test-filter", StringComparison.OrdinalIgnoreCase);
+
                 if (!string.IsNullOrEmpty(newtarget))
                 {
-                    if (cargs.Count <= 1)
+                    // test-filters takes source paths as positional arguments and has no target, so a
+                    // --target from the parameters file must not become a bogus positional source (#4812).
+                    if (isTestFilters)
+                        Library.Logging.Log.WriteVerboseMessage(LOGTAG, "NotUsingTarget", Strings.Program.SkippingTargetArgumentOnTestFilters);
+                    else if (cargs.Count <= 1)
                         cargs.Add(newtarget);
                     else
                         cargs[1] = newtarget;
                 }
 
-                if (cargs.Count >= 1 && cargs[0].Equals("backup", StringComparison.OrdinalIgnoreCase))
+                // backup and test-filters take source paths as positional arguments.
+                if (isBackup || isTestFilters)
                     cargs.AddRange(newsource);
                 else if (newsource.Count > 0)
                     Library.Logging.Log.WriteVerboseMessage(LOGTAG, "NotUsingBackupSources", Strings.Program.SkippingSourceArgumentsOnNonBackupOperation);
diff --git a/Duplicati/CommandLine/CLI/Strings.cs b/Duplicati/CommandLine/CLI/Strings.cs
index b8cab8695..2b0befbe9 100644
--- a/Duplicati/CommandLine/CLI/Strings.cs
+++ b/Duplicati/CommandLine/CLI/Strings.cs
@@ -54,6 +54,7 @@ namespace Duplicati.CommandLine.Strings
         public static string QuietConsoleOptionLong { get { return LC.L(@"If this option is set, progress reports and other messages that would normally go to the console will be redirected to the log."); } }
         public static string QuietConsoleOptionShort { get { return LC.L(@"Disable console output"); } }
         public static string SkippingSourceArgumentsOnNonBackupOperation { get { return @"The --source argument was specified in the parameter file, but the current operation is not a backup operation, so the argument is ignored."; } }
+        public static string SkippingTargetArgumentOnTestFilters { get { return @"The --target argument was specified in the parameter file, but the test-filters operation has no target, so the argument is ignored."; } }
         public static string AutoUpdateOptionShort { get { return LC.L(@"Toggle automatic updates"); } }
         public static string AutoUpdateOptionLong { get { return LC.L(@"Set this option if you prefer to have the commandline version automatically update"); } }
         public static string PortableModeOptionShort { get { return LC.L(@"Use portable mode"); } }
diff --git a/Duplicati/UnitTest/Issue4812.cs b/Duplicati/UnitTest/Issue4812.cs
new file mode 100644
index 000000000..d084d8c25
--- /dev/null
+++ b/Duplicati/UnitTest/Issue4812.cs
@@ -0,0 +1,83 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+using NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Duplicati.UnitTest
+{
+    public class Issue4812 : BasicSetupHelper
+    {
+        /// <summary>
+        /// https://github.com/duplicati/duplicati/issues/4812
+        /// `test-filters --parameters-file=...` must test the --source paths listed in the
+        /// parameters file. Previously the parameters-file handling only appended --source for the
+        /// `backup` command and always injected --target as the first positional argument, so for
+        /// test-filters the --source entries were dropped and the --target was tested as the (bogus)
+        /// source path — matching zero files.
+        /// </summary>
+        [Test]
+        [Category("Targeted")]
+        public void TestFiltersUsesSourceFromParametersFile()
+        {
+            // A source folder with a known number of plain files.
+            var sourceFolder = Path.Combine(DATAFOLDER, "src");
+            Directory.CreateDirectory(sourceFolder);
+            const int fileCount = 3;
+            for (var i = 0; i < fileCount; i++)
+                File.WriteAllText(Path.Combine(sourceFolder, $"file{i}.txt"), "content " + i);
+
+            // A shared-style parameters file carrying both --target (used by backup) and --source.
+            var paramFile = Path.Combine(DATAFOLDER, "params.txt");
+            File.WriteAllLines(paramFile, new[]
+            {
+                "--source=" + sourceFolder,
+                "--target=file://" + TARGETFOLDER
+            });
+
+            var sb = new StringBuilder();
+            var err = new StringBuilder();
+            int exit;
+            using (var sw = new StringWriter(sb))
+            using (var ew = new StringWriter(err))
+                exit = Duplicati.CommandLine.Program.RunCommandLine(sw, ew, _ => { }, new[]
+                {
+                    "test-filters",
+                    "--parameters-file=" + paramFile
+                });
+
+            var output = sb.ToString();
+            Assert.AreEqual(0, exit, "test-filters should succeed" + Environment.NewLine + output + Environment.NewLine + err);
+
+            var m = Regex.Match(output, @"Matched (\d+) files");
+            Assert.IsTrue(m.Success, "Expected a 'Matched N files' summary" + Environment.NewLine + output);
+
+            var matched = int.Parse(m.Groups[1].Value);
+            // The --source folder's files must have been tested. Before the fix this was 0, because
+            // --target was injected as the tested path and --source was ignored.
+            Assert.AreEqual(fileCount, matched, "test-filters should have matched the --source files" + Environment.NewLine + output);
+        }
+    }
+}

From 214480e8e6a93f495d436b63abf07a29fa2a6e4b Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Sun, 12 Jul 2026 04:58:55 +0900
Subject: [PATCH 16/19] Remove redundant cancel button from restore progress

The legacy ngax restore progress showed a "Cancel" button inside the
`wait-area` (restore.html) in addition to the existing stop control in the
top navigation bar. Restore cancellation already works via the top control
(StateController.stopDialog, which posts /task/{id}/stop or /abort); the extra
button called a separate /task/{id}/stop that was not handled by the restore
flow, so it was redundant and confusing.

Remove the redundant button and its dedicated handler:
- restore.html: drop `allow-cancel="true"` from the wait-area.
- waitarea.html: remove the Cancel button block.
- waitArea.js: remove the `allowCancel` binding, `cancelTask()`, and the now
  unused `AppService` dependency.

Legacy ngax UI only; the new ngclient UI does not have this button. No backend,
API, cancellation, or restore behavior is changed.

Fixes #4453
---
 .../Server/webroot/ngax/scripts/directives/waitArea.js    | 8 ++------
 Duplicati/Server/webroot/ngax/templates/restore.html      | 2 +-
 Duplicati/Server/webroot/ngax/templates/waitarea.html     | 4 ----
 3 files changed, 3 insertions(+), 11 deletions(-)

diff --git a/Duplicati/Server/webroot/ngax/scripts/directives/waitArea.js b/Duplicati/Server/webroot/ngax/scripts/directives/waitArea.js
index cb0d4cb9d..181796b72 100644
--- a/Duplicati/Server/webroot/ngax/scripts/directives/waitArea.js
+++ b/Duplicati/Server/webroot/ngax/scripts/directives/waitArea.js
@@ -3,16 +3,12 @@ backupApp.directive('waitArea', function() {
     restrict: 'E',
     scope: {
         taskid: '=taskid',
-        text: '=text',
-        allowCancel: '=allowCancel'
+        text: '=text'
     },
     templateUrl: 'templates/waitarea.html',
-    controller: function($scope, ServerStatus, AppService) {
+    controller: function($scope, ServerStatus) {
         $scope.ServerStatus = ServerStatus;
         $scope.serverstate = ServerStatus.watch($scope);
-        $scope.cancelTask = function() {
-            AppService.post('/task/' + $scope.taskid + '/stop');
-        };
     }
   }
 });
diff --git a/Duplicati/Server/webroot/ngax/templates/restore.html b/Duplicati/Server/webroot/ngax/templates/restore.html
index d09f1b1a8..1f7601a72 100644
--- a/Duplicati/Server/webroot/ngax/templates/restore.html
+++ b/Duplicati/Server/webroot/ngax/templates/restore.html
@@ -149,7 +149,7 @@
         </div>
 
         <div ng-show="connecting == true &amp;&amp; taskid != null">
-            <wait-area taskid="taskid" text="ConnectionProgress" allow-cancel="true"></wait-area>
+            <wait-area taskid="taskid" text="ConnectionProgress"></wait-area>
         </div>
 
         <div ng-show="connecting == true &amp;&amp; taskid == null">
diff --git a/Duplicati/Server/webroot/ngax/templates/waitarea.html b/Duplicati/Server/webroot/ngax/templates/waitarea.html
index 7001e753d..6c07dc1a9 100644
--- a/Duplicati/Server/webroot/ngax/templates/waitarea.html
+++ b/Duplicati/Server/webroot/ngax/templates/waitarea.html
@@ -15,8 +15,4 @@
         {{'Server is currently paused,' | translate}} <a style="cursor: pointer" ng-click="ServerStatus.resume()" translate>resume now</a>
     </div>
 
-    <div ng-show="allowCancel">
-        <a href class="button" ng-click="cancelTask()" translate>Cancel</a>
-    </div>
-
 </div>

From 1d4642acdf70290c552381782bdfaeb32f20a446 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Sun, 12 Jul 2026 06:56:54 +0900
Subject: [PATCH 17/19] Do not attach stack traces to known-problem path
 warnings (#6426)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

During a backup, LogExceptionHelper.LogCommonWarning is the shared helper used
to log "excluding path" warnings from many enumeration/metadata steps. For known,
expected problems (permission denied, locked file, path not found, path too long)
it passed the exception to WriteWarningMessage, so the file log, console and
report modules rendered the full stack trace (via LogEntry.AsString(true)) for
every such path — bloating the logs with no diagnostic value.

The known-category branches now log without attaching the exception, so no stack
trace is stored; the self-describing warning message (e.g. "Excluding path due to
permission denied: <path>") remains. The fallback branch keeps the exception so
genuinely unexpected failures are still fully debuggable.

Adds Issue6426 tests asserting known-problem warnings carry no exception while
unknown errors keep it.

Fixes #6426

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../Operation/Backup/LogExceptionHelper.cs    | 12 ++-
 Duplicati/UnitTest/Issue6426.cs               | 82 +++++++++++++++++++
 2 files changed, 90 insertions(+), 4 deletions(-)
 create mode 100644 Duplicati/UnitTest/Issue6426.cs

diff --git a/Duplicati/Library/Main/Operation/Backup/LogExceptionHelper.cs b/Duplicati/Library/Main/Operation/Backup/LogExceptionHelper.cs
index 13118d192..8f84f08a9 100644
--- a/Duplicati/Library/Main/Operation/Backup/LogExceptionHelper.cs
+++ b/Duplicati/Library/Main/Operation/Backup/LogExceptionHelper.cs
@@ -42,14 +42,18 @@ public static class LogExceptionHelper
     /// <param name="message">The message to log</param>
     public static void LogCommonWarning(Exception? ex, string logtag, string id, string path, string message = "Failed to process path: {0}")
     {
+        // For known, expected path problems the warning message already describes the cause,
+        // so the exception (and its stack trace) is not attached: it would only bloat the logs
+        // (issue #6426). The fallback below keeps the exception so genuinely unexpected failures
+        // remain fully debuggable.
         if (ex.IsPermissionDeniedException())
-            Log.WriteWarningMessage(logtag, "PermissionDenied", ex, "Excluding path due to permission denied: {0}", path);
+            Log.WriteWarningMessage(logtag, "PermissionDenied", null, "Excluding path due to permission denied: {0}", path);
         else if (ex.IsFileLockedException())
-            Log.WriteWarningMessage(logtag, "FileLocked", ex, "Excluding path due to file locked: {0}", path);
+            Log.WriteWarningMessage(logtag, "FileLocked", null, "Excluding path due to file locked: {0}", path);
         else if (ex.IsPathNotFoundException())
-            Log.WriteWarningMessage(logtag, "PathNotFound", ex, "Excluding path due to path not found: {0}", path);
+            Log.WriteWarningMessage(logtag, "PathNotFound", null, "Excluding path due to path not found: {0}", path);
         else if (ex.IsPathTooLongException())
-            Log.WriteWarningMessage(logtag, "PathTooLong", ex, "Excluding path due to path too long: {0}", path);
+            Log.WriteWarningMessage(logtag, "PathTooLong", null, "Excluding path due to path too long: {0}", path);
         else
             Log.WriteWarningMessage(logtag, id, ex, message, path);
 
diff --git a/Duplicati/UnitTest/Issue6426.cs b/Duplicati/UnitTest/Issue6426.cs
new file mode 100644
index 000000000..7245d33a0
--- /dev/null
+++ b/Duplicati/UnitTest/Issue6426.cs
@@ -0,0 +1,82 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Duplicati.Library.Logging;
+using Duplicati.Library.Main.Operation.Backup;
+using NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Duplicati.UnitTest
+{
+    /// <summary>
+    /// https://github.com/duplicati/duplicati/issues/6426
+    /// Warnings for known, expected path problems (permission denied, locked file, path not
+    /// found, path too long) must not carry the exception, so their (large) stack traces do not
+    /// bloat the log. Genuinely unexpected errors still keep the exception for debugging.
+    /// </summary>
+    public class Issue6426
+    {
+        private static List<LogEntry> CaptureWarnings(Exception ex, string callerId)
+        {
+            var captured = new List<LogEntry>();
+            using (Log.StartScope(e => captured.Add(e)))
+                LogExceptionHelper.LogCommonWarning(ex, "TestTag", callerId, "/some/path");
+            return captured.Where(e => e.Level == LogMessageType.Warning).ToList();
+        }
+
+        [Test]
+        [Category("Targeted")]
+        public void KnownPathWarningsCarryNoException()
+        {
+            // These exception types are recognised as "known problems" on every platform.
+            var cases = new (Exception Exception, string ExpectedId)[]
+            {
+                (new UnauthorizedAccessException("denied"), "PermissionDenied"),
+                (new FileNotFoundException("missing"), "PathNotFound"),
+                (new PathTooLongException("too long"), "PathTooLong"),
+            };
+
+            foreach (var c in cases)
+            {
+                var warnings = CaptureWarnings(c.Exception, "SomeCallerId");
+                Assert.AreEqual(1, warnings.Count, "Expected exactly one warning for " + c.ExpectedId);
+                Assert.AreEqual(c.ExpectedId, warnings[0].Id, "Unexpected warning id");
+                Assert.IsNull(warnings[0].Exception,
+                    c.ExpectedId + " is a known problem and must not attach the exception (no stack trace)");
+            }
+        }
+
+        [Test]
+        [Category("Targeted")]
+        public void UnknownPathWarningKeepsExceptionForDebugging()
+        {
+            var ex = new InvalidOperationException("unexpected");
+            var warnings = CaptureWarnings(ex, "CustomId");
+            Assert.AreEqual(1, warnings.Count);
+            Assert.AreEqual("CustomId", warnings[0].Id, "Unknown errors should use the caller-supplied id");
+            Assert.AreSame(ex, warnings[0].Exception, "Unknown errors must keep the exception for debugging");
+        }
+    }
+}

From de481748424e09953b3f47ae37714a18a97f7f42 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Sun, 12 Jul 2026 12:11:26 +0900
Subject: [PATCH 18/19] Stabilize ZipFallback database cleanup on Windows

---
 Duplicati/UnitTest/ZipFallbackTest.cs | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/Duplicati/UnitTest/ZipFallbackTest.cs b/Duplicati/UnitTest/ZipFallbackTest.cs
index 9f1e4d1ca..15fd67dc3 100644
--- a/Duplicati/UnitTest/ZipFallbackTest.cs
+++ b/Duplicati/UnitTest/ZipFallbackTest.cs
@@ -31,6 +31,27 @@ namespace Duplicati.UnitTest
 {
     public class ZipFallbackTest : BasicSetupHelper
     {
+        private static async Task DeleteDatabaseWithRetryAsync(string path)
+        {
+            const int maxAttempts = 10;
+
+            for (var attempt = 1; ; attempt++)
+            {
+                try
+                {
+                    File.Delete(path);
+                    return;
+                }
+                catch (IOException) when (OperatingSystem.IsWindows() && attempt < maxAttempts)
+                {
+                    // Windows can retain SQLite file handles until pending finalizers complete.
+                    GC.Collect();
+                    GC.WaitForPendingFinalizers();
+                    await Task.Delay(TimeSpan.FromSeconds(1)).ConfigureAwait(false);
+                }
+            }
+        }
+
         [Test]
         [Category("Targeted")]
         public async Task FallbackToSharpCompressOnDecompressLzmaStreamsAsync()
@@ -50,7 +71,7 @@ namespace Duplicati.UnitTest
             }
 
             // Delete the local database
-            File.Delete(DBFILE);
+            await DeleteDatabaseWithRetryAsync(DBFILE);
 
             // Switch back to built-in compression
             testopts.Remove("zip-compression-method");
@@ -116,7 +137,7 @@ namespace Duplicati.UnitTest
             }
 
             // Delete the local database
-            File.Delete(DBFILE);
+            await DeleteDatabaseWithRetryAsync(DBFILE);
 
             // Recreate the database
             using (var c = new Library.Main.Controller("file://" + TARGETFOLDER, testopts, null))

From aafc94fb692332a9ede2e99332038c211c9e1883 Mon Sep 17 00:00:00 2001
From: JamBalaya56562 <jambalaya.pyoncafe@outlook.jp>
Date: Sun, 12 Jul 2026 12:32:01 +0900
Subject: [PATCH 19/19] Delete the incomplete recreate database when the remote
 is empty (#6205)

When all files are deleted from the remote destination and the user runs repair
(which recreates the local database), the recreate fails because the destination
is empty. Previously the partial/empty database that had just been created was
left on disk, which blocked every subsequent operation: a fresh backup could not
run, and even retrying the repair failed because the recreate refuses to run when
the database file already exists.

RecreateDatabaseHandler.RunAsync now removes the database it created when the
recreate fails because the remote destination is empty (UserInformationException
with help id EmptyRemoteLocation / EmptyRemoteLocationWithPrefix), so the next run
starts cleanly. The database connection is disposed before the cleanup runs, so the
file is not locked, and the cleanup is best-effort and never masks the original error.

The cleanup is deliberately scoped to the empty-destination case. Other recreate
failures - in particular a database with missing blocks / broken filelists (help id
DatabaseIsBrokenConsiderPurge) - intentionally keep the recreated database so the
user can run list-broken-files / purge-broken-files against it.

Adds an Issue6205 regression test.

Fixes #6205

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../Main/Operation/RecreateDatabaseHandler.cs | 48 +++++++--
 Duplicati/UnitTest/Issue6205.cs               | 98 +++++++++++++++++++
 2 files changed, 138 insertions(+), 8 deletions(-)
 create mode 100644 Duplicati/UnitTest/Issue6205.cs

diff --git a/Duplicati/Library/Main/Operation/RecreateDatabaseHandler.cs b/Duplicati/Library/Main/Operation/RecreateDatabaseHandler.cs
index 6df32dd8f..6d4d0cdec 100644
--- a/Duplicati/Library/Main/Operation/RecreateDatabaseHandler.cs
+++ b/Duplicati/Library/Main/Operation/RecreateDatabaseHandler.cs
@@ -64,16 +64,48 @@ namespace Duplicati.Library.Main.Operation
             if (File.Exists(path))
                 throw new UserInformationException(string.Format("Cannot recreate database because file already exists: {0}", path), "RecreateTargetDatabaseExists");
 
-            await using var db =
-                await LocalDatabase.CreateLocalDatabaseAsync(path, "Recreate", true, null, m_result.TaskControl.ProgressToken)
+            try
+            {
+                await using var db =
+                    await LocalDatabase.CreateLocalDatabaseAsync(path, "Recreate", true, null, m_result.TaskControl.ProgressToken)
+                        .ConfigureAwait(false);
+
+                await DoRunAsync(backendManager, db, false, filter, filelistfilter, blockprocessor).ConfigureAwait(false);
+
+                // Ensure database is consistent after the recreate
+                await db
+                    .VerifyConsistencyAsync(m_options.Blocksize, m_options.BlockhashSize, true, m_result.TaskControl.ProgressToken)
                     .ConfigureAwait(false);
+            }
+            catch (UserInformationException uex) when (uex.HelpID == "EmptyRemoteLocation" || uex.HelpID == "EmptyRemoteLocationWithPrefix")
+            {
+                // The remote destination is empty (#6205): the freshly-created database is empty and
+                // would block further operations - a fresh backup cannot run, and even a retry fails
+                // because RunAsync refuses to run when the file already exists. Remove it so the next
+                // run starts cleanly. The database connection is already disposed by the await-using
+                // above (the using scope is left before this catch runs), so the file is no longer
+                // locked.
+                //
+                // Only the empty-destination case is cleaned up. Other recreate failures - notably a
+                // database with missing blocks / broken filelists (help id "DatabaseIsBrokenConsiderPurge")
+                // - intentionally KEEP the recreated database so the user can run list-broken-files /
+                // purge-broken-files against it; those exceptions do not match this filter and propagate
+                // with the database left in place. This is best-effort and must never mask the error.
+                try
+                {
+                    if (File.Exists(path))
+                    {
+                        File.Delete(path);
+                        Logging.Log.WriteInformationMessage(LOGTAG, "RemovedIncompleteRecreateDatabase", "Removed incomplete recreate database at {0}", path);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    Logging.Log.WriteWarningMessage(LOGTAG, "RecreateCleanupFailed", ex, "Failed to remove incomplete recreate database at {0}: {1}", path, ex.Message);
+                }
 
-            await DoRunAsync(backendManager, db, false, filter, filelistfilter, blockprocessor).ConfigureAwait(false);
-
-            // Ensure database is consistent after the recreate
-            await db
-                .VerifyConsistencyAsync(m_options.Blocksize, m_options.BlockhashSize, true, m_result.TaskControl.ProgressToken)
-                .ConfigureAwait(false);
+                throw;
+            }
         }
 
         /// <summary>
diff --git a/Duplicati/UnitTest/Issue6205.cs b/Duplicati/UnitTest/Issue6205.cs
new file mode 100644
index 000000000..43497e901
--- /dev/null
+++ b/Duplicati/UnitTest/Issue6205.cs
@@ -0,0 +1,98 @@
+// Copyright (C) 2026, The Duplicati Team
+// https://duplicati.com, hello@duplicati.com
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Duplicati.Library.Main;
+using NUnit.Framework;
+using Assert = NUnit.Framework.Legacy.ClassicAssert;
+
+namespace Duplicati.UnitTest
+{
+    public class Issue6205 : BasicSetupHelper
+    {
+        /// <summary>
+        /// https://github.com/duplicati/duplicati/issues/6205
+        /// If all files are deleted from the remote destination and the user then runs repair
+        /// (which recreates the local database), the recreate fails because the destination is
+        /// empty. Previously the partial/empty database that was created was left on disk, which
+        /// blocked every subsequent operation — a fresh backup could not run, and even retrying
+        /// the repair failed because the recreate refuses to run when the database file exists.
+        /// The failed recreate must remove the incomplete database so a fresh backup can proceed.
+        /// </summary>
+        [Test]
+        [Category("Targeted")]
+        public async Task RepairOnEmptyDestinationDoesNotLeavePartialDatabase()
+        {
+            var options = new Dictionary<string, string>(this.TestOptions)
+            {
+                ["no-encryption"] = "true"
+            };
+
+            File.WriteAllText(Path.Combine(this.DATAFOLDER, "a.txt"), "hello");
+            File.WriteAllText(Path.Combine(this.DATAFOLDER, "b.txt"), "world");
+
+            // Initial backup: creates the remote volumes and the local database.
+            using (var c = new Controller("file://" + this.TARGETFOLDER, options, null))
+            {
+                var backupResults = await c.BackupAsync([this.DATAFOLDER]);
+                Assert.AreEqual(0, backupResults.Errors.Count());
+            }
+            Assert.IsTrue(File.Exists(options["dbpath"]), "The local database should exist after a backup");
+
+            // Simulate "all files deleted on the remote": empty the destination and drop the
+            // local database so the next repair goes through the recreate-from-remote path.
+            File.Delete(options["dbpath"]);
+            foreach (var f in Directory.GetFiles(this.TARGETFOLDER))
+                File.Delete(f);
+
+            // Repair now has to recreate the database from an empty destination, which fails.
+            Exception repairFailure = null;
+            using (var c = new Controller("file://" + this.TARGETFOLDER, options, null))
+            {
+                try
+                {
+                    await c.RepairAsync();
+                }
+                catch (Exception ex)
+                {
+                    repairFailure = ex;
+                }
+            }
+            Assert.IsNotNull(repairFailure, "Repair against an empty destination is expected to fail");
+
+            // The incomplete recreate database must NOT be left behind (this is the fix).
+            Assert.IsFalse(File.Exists(options["dbpath"]),
+                "The incomplete recreate database should have been removed after the failed repair");
+
+            // With the leftover database gone, a fresh backup must be able to run again.
+            using (var c = new Controller("file://" + this.TARGETFOLDER, options, null))
+            {
+                var backupResults = await c.BackupAsync([this.DATAFOLDER]);
+                Assert.AreEqual(0, backupResults.Errors.Count(),
+                    "A fresh backup should succeed after the failed repair cleaned up the partial database");
+            }
+        }
+    }
+}