diff --git a/ErsatzTV.Scanner.Tests/Application/MediaSources/ScanLocalLibraryHandlerTests.cs b/ErsatzTV.Scanner.Tests/Application/MediaSources/ScanLocalLibraryHandlerTests.cs
new file mode 100644
index 000000000..f702f75bd
--- /dev/null
+++ b/ErsatzTV.Scanner.Tests/Application/MediaSources/ScanLocalLibraryHandlerTests.cs
@@ -0,0 +1,173 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Scanner.Application.MediaSources;
+using ErsatzTV.Scanner.Core.Interfaces;
+using ErsatzTV.Scanner.Core.Interfaces.Metadata;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Scanner.Tests.Application.MediaSources;
+
+public class ScanLocalLibraryHandlerTests
+{
+    [TestFixture]
+    public class Handle
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            // the handler validates that the configured ffmpeg/ffprobe paths exist on disk
+            _ffmpegPath = Path.GetTempFileName();
+            _ffprobePath = Path.GetTempFileName();
+
+            _scannerProxy = Substitute.For<IScannerProxy>();
+            _libraryRepository = Substitute.For<ILibraryRepository>();
+            _configElementRepository = Substitute.For<IConfigElementRepository>();
+            _movieFolderScanner = Substitute.For<IMovieFolderScanner>();
+
+            _library = new LocalLibrary
+            {
+                Id = 42,
+                Name = "Movies",
+                MediaKind = LibraryMediaKind.Movies,
+                MediaSourceId = 1,
+                Paths = [new LibraryPath { Id = 1, Path = "/movies" }]
+            };
+
+            _libraryRepository.GetLibrary(_library.Id).Returns(Some<Library>(_library).AsTask());
+
+            ConfigValue(ConfigElementKey.FFmpegPath, _ffmpegPath);
+            ConfigValue(ConfigElementKey.FFprobePath, _ffprobePath);
+            ConfigValue(ConfigElementKey.LibraryRefreshInterval, 0);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            File.Delete(_ffmpegPath);
+            File.Delete(_ffprobePath);
+        }
+
+        private string _ffmpegPath;
+        private string _ffprobePath;
+        private IScannerProxy _scannerProxy;
+        private ILibraryRepository _libraryRepository;
+        private IConfigElementRepository _configElementRepository;
+        private IMovieFolderScanner _movieFolderScanner;
+        private LocalLibrary _library;
+
+        [Test]
+        public async Task Should_Set_Library_LastScan_After_Successful_Scan()
+        {
+            ScanResult(Right<BaseError, Unit>(Unit.Default));
+
+            Either<BaseError, string> result = await Handler().Handle(
+                new ScanLocalLibrary("http://ersatztv.example", _library.Id, true),
+                CancellationToken.None);
+
+            result.IsRight.ShouldBeTrue();
+
+            // the regression: only the path-level LastScan was written, so the API's
+            // library-level scan time stayed null and the SPA showed "Never scanned" forever
+            _library.LastScan.ShouldNotBeNull();
+            await _libraryRepository.Received(1).UpdateLastScan(_library);
+            await _libraryRepository.Received(1).UpdateLastScan(_library.Paths[0]);
+        }
+
+        [Test]
+        public async Task Should_Not_Set_Library_LastScan_When_A_Path_Scan_Fails()
+        {
+            ScanResult(Left<BaseError, Unit>(new BaseError("scan failed")));
+
+            await Handler().Handle(
+                new ScanLocalLibrary("http://ersatztv.example", _library.Id, true),
+                CancellationToken.None);
+
+            _library.LastScan.ShouldBeNull();
+            await _libraryRepository.DidNotReceive().UpdateLastScan(Arg.Any<Library>());
+        }
+
+        [Test]
+        public async Task Should_Not_Set_Library_LastScan_When_A_Later_Path_Fails()
+        {
+            var goodPath = new LibraryPath { Id = 1, Path = "/movies" };
+            var badPath = new LibraryPath { Id = 2, Path = "/more-movies" };
+            _library.Paths = [goodPath, badPath];
+
+            _movieFolderScanner.ScanFolder(
+                    goodPath,
+                    _ffmpegPath,
+                    _ffprobePath,
+                    Arg.Any<decimal>(),
+                    Arg.Any<decimal>(),
+                    Arg.Any<CancellationToken>())
+                .Returns(Right<BaseError, Unit>(Unit.Default).AsTask());
+            _movieFolderScanner.ScanFolder(
+                    badPath,
+                    _ffmpegPath,
+                    _ffprobePath,
+                    Arg.Any<decimal>(),
+                    Arg.Any<decimal>(),
+                    Arg.Any<CancellationToken>())
+                .Returns(Left<BaseError, Unit>(new BaseError("scan failed")).AsTask());
+
+            await Handler().Handle(
+                new ScanLocalLibrary("http://ersatztv.example", _library.Id, true),
+                CancellationToken.None);
+
+            // a partially-scanned library must not claim a successful scan time
+            _library.LastScan.ShouldBeNull();
+            await _libraryRepository.DidNotReceive().UpdateLastScan(Arg.Any<Library>());
+            await _libraryRepository.Received(1).UpdateLastScan(goodPath);
+        }
+
+        [Test]
+        public async Task Should_Not_Set_Library_LastScan_When_Scan_Is_Skipped()
+        {
+            ScanResult(Right<BaseError, Unit>(Unit.Default));
+            _library.Paths[0].LastScan = DateTime.UtcNow;
+            ConfigValue(ConfigElementKey.LibraryRefreshInterval, 6);
+
+            await Handler().Handle(
+                new ScanLocalLibrary("http://ersatztv.example", _library.Id, false),
+                CancellationToken.None);
+
+            // nothing was scanned, so there is no new scan time to record
+            _library.LastScan.ShouldBeNull();
+            await _libraryRepository.DidNotReceive().UpdateLastScan(Arg.Any<Library>());
+        }
+
+        private void ConfigValue<T>(ConfigElementKey key, T value) =>
+            _configElementRepository.GetValue<T>(
+                    Arg.Is<ConfigElementKey>(k => k.Key == key.Key),
+                    Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult<Option<T>>(Some(value)));
+
+        private void ScanResult(Either<BaseError, Unit> result) =>
+            _movieFolderScanner.ScanFolder(
+                    Arg.Any<LibraryPath>(),
+                    _ffmpegPath,
+                    _ffprobePath,
+                    Arg.Any<decimal>(),
+                    Arg.Any<decimal>(),
+                    Arg.Any<CancellationToken>())
+                .Returns(result.AsTask());
+
+        private ScanLocalLibraryHandler Handler() =>
+            new(
+                _scannerProxy,
+                _libraryRepository,
+                _configElementRepository,
+                _movieFolderScanner,
+                Substitute.For<ITelevisionFolderScanner>(),
+                Substitute.For<IMusicVideoFolderScanner>(),
+                Substitute.For<IOtherVideoFolderScanner>(),
+                Substitute.For<ISongFolderScanner>(),
+                Substitute.For<IImageFolderScanner>(),
+                Substitute.For<IRemoteStreamFolderScanner>(),
+                Substitute.For<ILogger<ScanLocalLibraryHandler>>());
+    }
+}
diff --git a/ErsatzTV.Scanner/Application/MediaSources/Commands/ScanLocalLibraryHandler.cs b/ErsatzTV.Scanner/Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
index e2ec05a77..f24a68818 100644
--- a/ErsatzTV.Scanner/Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
+++ b/ErsatzTV.Scanner/Application/MediaSources/Commands/ScanLocalLibraryHandler.cs
@@ -1,4 +1,4 @@
-using System.Diagnostics;
+using System.Diagnostics;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Interfaces.Repositories;
@@ -65,6 +65,7 @@ public class ScanLocalLibraryHandler : IRequestHandler<ScanLocalLibrary, Either<
         _scannerProxy.SetBaseUrl(baseUrl);
 
         var scanned = false;
+        var anyFailed = false;
 
         for (var i = 0; i < localLibrary.Paths.Count; i++)
         {
@@ -145,6 +146,10 @@ public class ScanLocalLibraryHandler : IRequestHandler<ScanLocalLibrary, Either<
                     libraryPath.LastScan = DateTime.UtcNow;
                     await _libraryRepository.UpdateLastScan(libraryPath);
                 }
+                else
+                {
+                    anyFailed = true;
+                }
             }
 
             await _scannerProxy.UpdateProgress(progressMax, cancellationToken);
@@ -152,6 +157,15 @@ public class ScanLocalLibraryHandler : IRequestHandler<ScanLocalLibrary, Either<
 
         sw.Stop();
 
+        // the library-level LastScan drives the "last scanned" / "Never scanned" badge in the API and SPA,
+        // and is separate from the per-path LastScan that gates the refresh interval above. Only record it
+        // when every path that ran succeeded, mirroring the remote scanners (which set it solely on IsRight).
+        if (scanned && !anyFailed)
+        {
+            localLibrary.LastScan = DateTime.UtcNow;
+            await _libraryRepository.UpdateLastScan(localLibrary);
+        }
+
         if (scanned)
         {
             _logger.LogDebug(