From 70611c2051ae180f0352de71e5f5de2acde540f0 Mon Sep 17 00:00:00 2001
From: Leonid Pershin <lpershin@syntellect.ru>
Date: Mon, 10 Aug 2026 11:29:58 +0300
Subject: [PATCH] Refactor metadata handling in PLib video library manager to
 improve video matching accuracy. Introduce new properties for tracking when
 metadata was applied and from which source. Update LibraryService and related
 components to utilize these properties, ensuring videos without synopses are
 correctly identified as matched. Enhance UI to display the library's own
 thumbnail alongside candidate matches, improving user decision-making. Revise
 README.md to reflect these changes and clarify metadata application
 processes.

---
 README.md                                     |  13 +-
 .../Abstractions/IVideoRepository.cs          |  67 ++-
 .../Library/LibraryService.cs                 |  41 +-
 .../Metadata/MetadataScanEvent.cs             |  36 +-
 src/PLib.Desktop/Themes/LibraryStyles.axaml   |  13 +
 .../ViewModels/MetadataScanResultViewModel.cs |   8 +
 .../ViewModels/MetadataScanScopeOption.cs     |  30 +
 .../ViewModels/MetadataScanViewModel.cs       |  12 +-
 src/PLib.Desktop/Views/MetadataScanView.axaml |  93 ++-
 .../Videos/AppliedMetadataSource.cs           |  38 ++
 src/PLib.Domain/Videos/VideoItem.cs           | 553 ++++++++++--------
 .../Persistence/EfVideoRepository.cs          |  99 ++--
 ...20260810080601_MetadataApplied.Designer.cs | 176 ++++++
 .../20260810080601_MetadataApplied.cs         |  51 ++
 ...0082839_AppliedMetadataSources.Designer.cs | 202 +++++++
 .../20260810082839_AppliedMetadataSources.cs  |  98 ++++
 .../LibraryDbContextModelSnapshot.cs          |  33 ++
 .../Persistence/VideoItemConfiguration.cs     | 171 +++---
 .../Library/InMemoryVideoRepository.cs        | 120 ++--
 tests/PLib.Tests/Library/MetadataScanTests.cs |  46 +-
 20 files changed, 1387 insertions(+), 513 deletions(-)
 create mode 100644 src/PLib.Desktop/ViewModels/MetadataScanScopeOption.cs
 create mode 100644 src/PLib.Domain/Videos/AppliedMetadataSource.cs
 create mode 100644 src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.Designer.cs
 create mode 100644 src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.cs
 create mode 100644 src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.Designer.cs
 create mode 100644 src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.cs

diff --git a/README.md b/README.md
index f32d24f..da405ff 100644
--- a/README.md
+++ b/README.md
@@ -27,8 +27,8 @@
   stash-box. Поиск по отпечатку запускается кнопкой на странице видео; найденное показывается
   списком, и применяется тем, что выбрали — название, описание, теги, актёры, студия.
 - Вкладка «Метаданные» — тот же поиск сразу по всей библиотеке, с прогрессом, остановкой
-  и списком найденного. Каждый кандидат показывается со своей обложкой. По желанию
-  однозначные совпадения применяются на месте.
+  и списком найденного. Рядом с кандидатами показывается наш собственный кадр, и каждая
+  картинка подписана, чья она. По желанию однозначные совпадения применяются на месте.
 - Светлая, тёмная и системная темы; выбор запоминается.
 - Встроенный плеер: клик по карточке открывает страницу медиа прямо в окне — видео,
   перемотка, громкость, кнопка «назад». Полноэкранный режим по F11 или кнопке, выход —
@@ -177,6 +177,15 @@ dotnet test
   видео, и тысяча одинаковых строк была бы всей страницей.
   «Применять однозначные сразу» по умолчанию выключено, а два кандидата не применяются никогда
   — расхождение источников это ровно тот случай, ради которого страницу и смотрят.
+  На странице подписана каждая картинка: наш кадр в акцентной рамке с подписью
+  «В библиотеке», кандидатский — в обычной, с именем источника. Решение принимается
+  глазами, и два неподписанных кадра рядом делают его невозможным даже сформулировать.
+  **Признак «уже размечено» — отдельная отметка, а не наличие описания.** Сначала прогон
+  пропускал видео с непустым `Description`, и это ломалось на источниках, у которых есть
+  название, актёры и теги, но нет синопсиса: такие видео возвращались на каждом запуске.
+  Теперь применение ставит `MetadataAppliedAt` и имя источника, а миграция проставляет
+  отметку тем, у кого описание уже есть, — иначе первый же запуск после обновления предложил
+  бы заново всё, что уже было сделано.
 - **Картинки скачиваются один раз и по размеру.** `images` в stash-box есть у сцены,
   у актёра и у студии; у тега такого поля нет вовсе, поэтому там карточка показывает первую
   букву — это норма, а не отсутствие данных. Обложка сцены нужна там, где выбирают из
diff --git a/src/PLib.Application/Abstractions/IVideoRepository.cs b/src/PLib.Application/Abstractions/IVideoRepository.cs
index 9ad75b5..07d17f4 100644
--- a/src/PLib.Application/Abstractions/IVideoRepository.cs
+++ b/src/PLib.Application/Abstractions/IVideoRepository.cs
@@ -1,30 +1,37 @@
-using PLib.Domain.Videos;
-
-namespace PLib.Application.Abstractions;
-
-/// <summary>
-/// Persistence boundary for the library. The application layer only ever talks to this
-/// interface, which keeps EF Core (and SQLite) an implementation detail of the outer ring.
-/// </summary>
-public interface IVideoRepository
-{
-    Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Every video with its labels loaded. Kept apart from <see cref="GetAllAsync"/> because
-    /// the scan reconciles thousands of rows against disk and has no use for the join.
-    /// </summary>
-    Task<IReadOnlyList<VideoItem>> GetAllWithLabelsAsync(CancellationToken cancellationToken = default);
-
-    Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default);
-
-    /// <summary>Loads one video together with the labels attached to it.</summary>
-    Task<VideoItem?> FindWithLabelsAsync(Guid id, CancellationToken cancellationToken = default);
-
-    Task AddAsync(VideoItem item, CancellationToken cancellationToken = default);
-
-    Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default);
-
-    /// <summary>Flushes every pending change made to tracked entities.</summary>
-    Task SaveChangesAsync(CancellationToken cancellationToken = default);
-}
+using PLib.Domain.Videos;
+
+namespace PLib.Application.Abstractions;
+
+/// <summary>
+/// Persistence boundary for the library. The application layer only ever talks to this
+/// interface, which keeps EF Core (and SQLite) an implementation detail of the outer ring.
+/// </summary>
+public interface IVideoRepository
+{
+    Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Every video with its labels loaded. Kept apart from <see cref="GetAllAsync"/> because
+    /// the scan reconciles thousands of rows against disk and has no use for the join.
+    /// </summary>
+    Task<IReadOnlyList<VideoItem>> GetAllWithLabelsAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Every video with the record of which metadata sources have been applied to it. A
+    /// separate method for the same reason as the labels one: the scan walks these rows
+    /// against disk thousands at a time and has no use for either join.
+    /// </summary>
+    Task<IReadOnlyList<VideoItem>> GetAllWithMetadataSourcesAsync(CancellationToken cancellationToken = default);
+
+    Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default);
+
+    /// <summary>Loads one video together with the labels attached to it.</summary>
+    Task<VideoItem?> FindWithLabelsAsync(Guid id, CancellationToken cancellationToken = default);
+
+    Task AddAsync(VideoItem item, CancellationToken cancellationToken = default);
+
+    Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default);
+
+    /// <summary>Flushes every pending change made to tracked entities.</summary>
+    Task SaveChangesAsync(CancellationToken cancellationToken = default);
+}
diff --git a/src/PLib.Application/Library/LibraryService.cs b/src/PLib.Application/Library/LibraryService.cs
index a5ab03d..4bb18d4 100644
--- a/src/PLib.Application/Library/LibraryService.cs
+++ b/src/PLib.Application/Library/LibraryService.cs
@@ -214,6 +214,31 @@ public sealed class LibraryService(
     public Task<RemoteImage> FetchImageAsync(string imageUrl, CancellationToken cancellationToken = default) =>
         remoteImages.GetOrCreateAsync(imageUrl, cancellationToken);
 
+    /// <summary>Whether a run of this scope has anything left to ask about this video.</summary>
+    private static bool Covers(
+        MetadataScanScope scope,
+        VideoItem video,
+        IReadOnlyList<MetadataSourceOptions> sources) => scope switch
+    {
+        MetadataScanScope.Unmatched => !video.HasMetadata,
+        MetadataScanScope.MissingSources => sources.Any(source => !video.HasMetadataFrom(source.Name)),
+        _ => true,
+    };
+
+    /// <summary>
+    /// Which sources to ask about this video.
+    /// </summary>
+    /// <remarks>
+    /// Narrowed only for <see cref="MetadataScanScope.MissingSources"/>, which exists precisely
+    /// because a source that has already had its say would spend a request to repeat itself.
+    /// </remarks>
+    private static IEnumerable<MetadataSourceOptions> SourcesFor(
+        MetadataScanScope scope,
+        VideoItem video,
+        IReadOnlyList<MetadataSourceOptions> sources) => scope == MetadataScanScope.MissingSources
+        ? sources.Where(source => !video.HasMetadataFrom(source.Name))
+        : sources;
+
     public async IAsyncEnumerable<MetadataScanEvent> ScanMetadataAsync(
         MetadataScanRequest request,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
@@ -225,9 +250,11 @@ public sealed class LibraryService(
         var sources = metadataOptions.CurrentValue.Sources.Where(source => source.IsUsable).ToList();
         var pause = TimeSpan.FromMilliseconds(metadataOptions.CurrentValue.RequestDelayMilliseconds);
 
-        var candidates = (await repository.GetAllAsync(cancellationToken))
+        // Asked of the record of having been matched, not of the description: a source with
+        // no synopsis leaves that empty, and such videos came back on every run.
+        var candidates = (await repository.GetAllWithMetadataSourcesAsync(cancellationToken))
             .Where(video => video.PerceptualHash is not null)
-            .Where(video => !request.OnlyWithoutDescription || video.Description is null)
+            .Where(video => Covers(request.Scope, video, sources))
             .OrderBy(video => video.Title, StringComparer.CurrentCultureIgnoreCase)
             .ToList();
 
@@ -244,7 +271,7 @@ public sealed class LibraryService(
 
             var found = new List<VideoMetadataMatch>();
 
-            foreach (var source in sources.Where(source => !abandoned.Contains(source)))
+            foreach (var source in SourcesFor(request.Scope, video, sources).Where(source => !abandoned.Contains(source)))
             {
                 if (pause > TimeSpan.Zero)
                 {
@@ -295,7 +322,12 @@ public sealed class LibraryService(
                     applied++;
                 }
 
-                yield return new MetadataScanEvent.Matched(video.Id, video.Title, found, unambiguous);
+                yield return new MetadataScanEvent.Matched(
+                    video.Id,
+                    video.Title,
+                    video.ThumbnailPath,
+                    found,
+                    unambiguous);
             }
 
             yield return new MetadataScanEvent.Progress(processed, candidates.Count);
@@ -326,6 +358,7 @@ public sealed class LibraryService(
         }
 
         video.Describe(match.Description);
+        video.MarkMetadataApplied(match.SourceName);
 
         await AttachAllAsync(video, match.Tags, LabelKind.Tag, cancellationToken);
         await AttachAllAsync(video, match.Performers, LabelKind.Performer, cancellationToken);
diff --git a/src/PLib.Application/Metadata/MetadataScanEvent.cs b/src/PLib.Application/Metadata/MetadataScanEvent.cs
index 3005434..4cc2842 100644
--- a/src/PLib.Application/Metadata/MetadataScanEvent.cs
+++ b/src/PLib.Application/Metadata/MetadataScanEvent.cs
@@ -1,16 +1,36 @@
 namespace PLib.Application.Metadata;
 
+/// <summary>Which videos a library-wide run should cover.</summary>
+public enum MetadataScanScope
+{
+    /// <summary>Only videos nothing has been applied to yet.</summary>
+    Unmatched,
+
+    /// <summary>
+    /// Videos that some configured source has not yet been asked about — and only those
+    /// sources are asked.
+    /// </summary>
+    /// <remarks>
+    /// What a newly added source is for: everything already carries PornDB's answers, and
+    /// the question now is what StashDB adds. Asking the source that already answered would
+    /// spend a request to be told what is already on the video.
+    /// </remarks>
+    MissingSources,
+
+    /// <summary>Every fingerprinted video, every source, regardless of what was applied.</summary>
+    Everything,
+}
+
 /// <summary>What a library-wide metadata run should cover and how much it may decide alone.</summary>
-/// <param name="OnlyWithoutDescription">
-/// Skip videos that already carry a description. A second run over a large library is usually
-/// meant to fill the gaps, not to ask again about everything that already worked.
-/// </param>
+/// <param name="Scope">Which videos to ask about, and which sources to ask.</param>
 /// <param name="ApplyUnambiguous">
 /// Apply a result without asking when exactly one source returned exactly one candidate.
 /// Off by default: a fingerprint match is a proposal, and several proposals disagreeing is
 /// precisely the case a human has to look at.
 /// </param>
-public sealed record MetadataScanRequest(bool OnlyWithoutDescription = true, bool ApplyUnambiguous = false);
+public sealed record MetadataScanRequest(
+    MetadataScanScope Scope = MetadataScanScope.Unmatched,
+    bool ApplyUnambiguous = false);
 
 /// <summary>Something that happened during a library-wide metadata run.</summary>
 public abstract record MetadataScanEvent
@@ -23,10 +43,16 @@ public abstract record MetadataScanEvent
     public sealed record Progress(int Processed, int Total) : MetadataScanEvent;
 
     /// <summary>A video the sources had something to say about.</summary>
+    /// <param name="VideoThumbnailPath">
+    /// The library's own poster frame for this video. Carried so the page can put it beside
+    /// the candidates: a fingerprint match is judged by eye, and there is nothing to judge
+    /// against if only the proposals have pictures.
+    /// </param>
     /// <param name="Applied">True when it was unambiguous and the run wrote it straight away.</param>
     public sealed record Matched(
         Guid VideoId,
         string VideoTitle,
+        string? VideoThumbnailPath,
         IReadOnlyList<VideoMetadataMatch> Matches,
         bool Applied) : MetadataScanEvent;
 
diff --git a/src/PLib.Desktop/Themes/LibraryStyles.axaml b/src/PLib.Desktop/Themes/LibraryStyles.axaml
index e6993f4..032e960 100644
--- a/src/PLib.Desktop/Themes/LibraryStyles.axaml
+++ b/src/PLib.Desktop/Themes/LibraryStyles.axaml
@@ -297,6 +297,19 @@
     <Setter Property="RenderTransform" Value="none" />
   </Style>
 
+  <!--
+    Says where a picture came from. Every frame on the metadata page carries one: the page
+    exists to decide whether a proposal is the same video as the file, and two unlabelled
+    frames side by side make that decision impossible to state, let alone make.
+  -->
+  <Style Selector="TextBlock.imageCaption">
+    <Setter Property="FontSize" Value="10.5" />
+    <Setter Property="FontWeight" Value="SemiBold" />
+    <Setter Property="MaxWidth" Value="128" />
+    <Setter Property="TextTrimming" Value="CharacterEllipsis" />
+    <Setter Property="Foreground" Value="{DynamicResource TextTertiaryBrush}" />
+  </Style>
+
   <Style Selector="TextBlock.taskTitle">
     <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}" />
     <Setter Property="FontSize" Value="12.5" />
diff --git a/src/PLib.Desktop/ViewModels/MetadataScanResultViewModel.cs b/src/PLib.Desktop/ViewModels/MetadataScanResultViewModel.cs
index f74ea3d..e037e64 100644
--- a/src/PLib.Desktop/ViewModels/MetadataScanResultViewModel.cs
+++ b/src/PLib.Desktop/ViewModels/MetadataScanResultViewModel.cs
@@ -16,6 +16,7 @@ public sealed partial class MetadataScanResultViewModel : ReactiveObject
 
         VideoId = matched.VideoId;
         VideoTitle = matched.VideoTitle;
+        VideoThumbnailPath = matched.VideoThumbnailPath;
 
         foreach (var match in matched.Matches)
         {
@@ -31,6 +32,13 @@ public sealed partial class MetadataScanResultViewModel : ReactiveObject
 
     public string VideoTitle { get; }
 
+    /// <summary>
+    /// Our own poster frame for the file, to compare the candidates against. Every picture on
+    /// this page is captioned with where it came from: the whole exercise is deciding whether
+    /// the proposal is the same video, and that is impossible if the two can be mixed up.
+    /// </summary>
+    public string? VideoThumbnailPath { get; }
+
     public ObservableCollection<MetadataMatchViewModel> Matches { get; } = [];
 
     public bool IsAmbiguous => Matches.Count > 1;
diff --git a/src/PLib.Desktop/ViewModels/MetadataScanScopeOption.cs b/src/PLib.Desktop/ViewModels/MetadataScanScopeOption.cs
new file mode 100644
index 0000000..8661ccd
--- /dev/null
+++ b/src/PLib.Desktop/ViewModels/MetadataScanScopeOption.cs
@@ -0,0 +1,30 @@
+using PLib.Application.Metadata;
+
+namespace PLib.Desktop.ViewModels;
+
+/// <summary>One choice of what a library-wide run should cover, with what it means.</summary>
+/// <remarks>
+/// The hint is shown under the picker rather than hidden in a tooltip. The three options
+/// differ by which requests they will send to somebody else's servers, and that difference is
+/// not something a two-word label can carry.
+/// </remarks>
+public sealed record MetadataScanScopeOption(MetadataScanScope Scope, string Label, string Hint)
+{
+    public static IReadOnlyList<MetadataScanScopeOption> All { get; } =
+    [
+        new(
+            MetadataScanScope.Unmatched,
+            "Только неразмеченные",
+            "Видео, к которым ещё не применялось ни одно совпадение."),
+
+        new(
+            MetadataScanScope.MissingSources,
+            "Источники, которых ещё не спрашивали",
+            "Для каждого видео опрашиваются только те источники, чьи данные к нему ещё не применяли. То, что нужно после добавления нового источника."),
+
+        new(
+            MetadataScanScope.Everything,
+            "Всё заново",
+            "Все видео с отпечатком и все источники, включая уже применённые."),
+    ];
+}
diff --git a/src/PLib.Desktop/ViewModels/MetadataScanViewModel.cs b/src/PLib.Desktop/ViewModels/MetadataScanViewModel.cs
index 61f8ebb..70811c8 100644
--- a/src/PLib.Desktop/ViewModels/MetadataScanViewModel.cs
+++ b/src/PLib.Desktop/ViewModels/MetadataScanViewModel.cs
@@ -42,6 +42,8 @@ public sealed partial class MetadataScanViewModel : ViewModelBase
         _refreshLibrary = refreshLibrary;
         _logger = logger;
 
+        SelectedScope = MetadataScanScopeOption.All[0];
+
         StartCommand = ReactiveCommand.CreateFromTask(
             RunAsync,
             this.WhenAnyValue(x => x.IsRunning).Select(running => !running));
@@ -59,6 +61,8 @@ public sealed partial class MetadataScanViewModel : ViewModelBase
         ObserveCommandFailures();
     }
 
+    public IReadOnlyList<MetadataScanScopeOption> Scopes => MetadataScanScopeOption.All;
+
     /// <summary>Videos the run found something for, newest first.</summary>
     public ObservableCollection<MetadataScanResultViewModel> Results { get; } = [];
 
@@ -78,9 +82,9 @@ public sealed partial class MetadataScanViewModel : ViewModelBase
     [Reactive]
     public partial string StatusText { get; set; } = "Опрос источников по отпечаткам всей библиотеки.";
 
-    /// <summary>Skip videos that already have a description; on by default.</summary>
+    /// <summary>What the run should cover; the narrowest option by default.</summary>
     [Reactive]
-    public partial bool OnlyWithoutDescription { get; set; } = true;
+    public partial MetadataScanScopeOption SelectedScope { get; set; }
 
     /// <summary>
     /// Write a result without asking when exactly one candidate came back. Off by default —
@@ -100,7 +104,7 @@ public sealed partial class MetadataScanViewModel : ViewModelBase
         Problems.Clear();
         StatusText = "Идёт опрос источников…";
 
-        var request = new MetadataScanRequest(OnlyWithoutDescription, ApplyUnambiguous);
+        var request = new MetadataScanRequest(SelectedScope.Scope, ApplyUnambiguous);
 
         try
         {
@@ -159,7 +163,7 @@ public sealed partial class MetadataScanViewModel : ViewModelBase
             case MetadataScanEvent.Completed completed:
                 Progress = 100;
                 StatusText = completed.Processed == 0
-                    ? "Нечего проверять — у видео ещё нет отпечатков, либо все уже описаны"
+                    ? "Нечего проверять — у видео ещё нет отпечатков, либо ко всем уже применены метаданные"
                     : $"Проверено {completed.Processed}, совпадения у {completed.WithMatches}, применено {completed.Applied}";
                 break;
 
diff --git a/src/PLib.Desktop/Views/MetadataScanView.axaml b/src/PLib.Desktop/Views/MetadataScanView.axaml
index c3f7078..12c0ac0 100644
--- a/src/PLib.Desktop/Views/MetadataScanView.axaml
+++ b/src/PLib.Desktop/Views/MetadataScanView.axaml
@@ -40,11 +40,24 @@
                      Text="{Binding StatusText}" />
         </Grid>
 
-        <StackPanel Orientation="Horizontal" Spacing="18">
-          <CheckBox Content="Только без описания" IsChecked="{Binding OnlyWithoutDescription}" />
+        <StackPanel Orientation="Horizontal" Spacing="14" VerticalAlignment="Center">
+          <TextBlock Classes="cardMeta" VerticalAlignment="Center" Text="Опрашивать:" />
+          <ComboBox MinWidth="300"
+                    ItemsSource="{Binding Scopes}"
+                    SelectedItem="{Binding SelectedScope}">
+            <ComboBox.ItemTemplate>
+              <DataTemplate x:DataType="vm:MetadataScanScopeOption">
+                <TextBlock Text="{Binding Label}" ToolTip.Tip="{Binding Hint}" />
+              </DataTemplate>
+            </ComboBox.ItemTemplate>
+          </ComboBox>
           <CheckBox Content="Применять однозначные сразу" IsChecked="{Binding ApplyUnambiguous}" />
         </StackPanel>
 
+        <TextBlock Classes="cardMeta"
+                   TextWrapping="Wrap"
+                   Text="{Binding SelectedScope.Hint}" />
+
         <!-- Sources that dropped out. Reported once each: a rejected key fails on every
              video, and a line per video would bury the results. -->
         <ItemsControl ItemsSource="{Binding Problems}">
@@ -74,15 +87,41 @@
                     Margin="0,0,0,10">
               <StackPanel Spacing="8">
 
-                <Grid ColumnDefinitions="*,Auto" ColumnSpacing="10">
-                  <TextBlock Grid.Column="0"
-                             Text="{Binding VideoTitle}"
-                             FontSize="13"
-                             FontWeight="SemiBold"
-                             TextWrapping="Wrap"
-                             Foreground="{DynamicResource TextPrimaryBrush}" />
+                <!--
+                  Ours, captioned. Deciding whether a proposal is the same video is done by
+                  eye, so the file's own frame has to be on the page — and every picture here
+                  says where it came from, because a page of unlabelled frames is worse than
+                  one with no frames at all.
+                -->
+                <Grid ColumnDefinitions="Auto,*,Auto" ColumnSpacing="10">
 
-                  <Border Grid.Column="1"
+                  <StackPanel Grid.Column="0" Spacing="3" VerticalAlignment="Top">
+                    <Border Width="128"
+                            Height="72"
+                            CornerRadius="7"
+                            ClipToBounds="True"
+                            BorderThickness="2"
+                            BorderBrush="{DynamicResource AccentBrush}"
+                            Background="{DynamicResource ThumbnailPlaceholderBrush}">
+                      <controls:AsyncImage Source="{Binding VideoThumbnailPath}" DecodeWidth="256" />
+                    </Border>
+                    <TextBlock Classes="imageCaption"
+                               Foreground="{DynamicResource AccentBrush}"
+                               Text="В библиотеке" />
+                  </StackPanel>
+
+                  <StackPanel Grid.Column="1" Spacing="3" VerticalAlignment="Center">
+                    <TextBlock Text="{Binding VideoTitle}"
+                               FontSize="13"
+                               FontWeight="SemiBold"
+                               TextWrapping="Wrap"
+                               Foreground="{DynamicResource TextPrimaryBrush}" />
+                    <TextBlock Classes="cardMeta"
+                               Text="Источники расходятся — выберите сами"
+                               IsVisible="{Binding IsAmbiguous}" />
+                  </StackPanel>
+
+                  <Border Grid.Column="2"
                           Classes="badge"
                           VerticalAlignment="Center"
                           IsVisible="{Binding AppliedFrom, Converter={x:Static ObjectConverters.IsNotNull}}">
@@ -90,27 +129,31 @@
                   </Border>
                 </Grid>
 
-                <TextBlock Classes="cardMeta"
-                           Text="Источники расходятся — выберите сами"
-                           IsVisible="{Binding IsAmbiguous}" />
+                <!-- The line between what we have and what is being proposed. -->
+                <Rectangle Height="1" Fill="{DynamicResource SurfaceBorderBrush}" />
 
                 <ItemsControl ItemsSource="{Binding Matches}">
                   <ItemsControl.ItemTemplate>
                     <DataTemplate x:DataType="vm:MetadataMatchViewModel">
                       <Grid ColumnDefinitions="Auto,*,Auto" ColumnSpacing="10" Margin="0,0,0,6">
 
-                        <!-- The candidate's own cover. Absent for a source that has none, and
-                             the row simply loses the column rather than reserving a blank. -->
-                        <Border Grid.Column="0"
-                                Width="128"
-                                Height="72"
-                                CornerRadius="7"
-                                ClipToBounds="True"
-                                VerticalAlignment="Top"
-                                Background="{DynamicResource ThumbnailPlaceholderBrush}"
-                                IsVisible="{Binding ImagePath, Converter={x:Static ObjectConverters.IsNotNull}}">
-                          <controls:AsyncImage Source="{Binding ImagePath}" DecodeWidth="256" />
-                        </Border>
+                        <!-- Theirs, captioned with the source. Neutral border against the
+                             accented one above, so the two can never be read the same way. -->
+                        <StackPanel Grid.Column="0"
+                                    Spacing="3"
+                                    VerticalAlignment="Top"
+                                    IsVisible="{Binding ImagePath, Converter={x:Static ObjectConverters.IsNotNull}}">
+                          <Border Width="128"
+                                  Height="72"
+                                  CornerRadius="7"
+                                  ClipToBounds="True"
+                                  BorderThickness="1"
+                                  BorderBrush="{DynamicResource CardBorderBrush}"
+                                  Background="{DynamicResource ThumbnailPlaceholderBrush}">
+                            <controls:AsyncImage Source="{Binding ImagePath}" DecodeWidth="256" />
+                          </Border>
+                          <TextBlock Classes="imageCaption" Text="{Binding SourceName}" />
+                        </StackPanel>
 
                         <StackPanel Grid.Column="1" Spacing="2">
                           <TextBlock Text="{Binding Title}"
diff --git a/src/PLib.Domain/Videos/AppliedMetadataSource.cs b/src/PLib.Domain/Videos/AppliedMetadataSource.cs
new file mode 100644
index 0000000..011efc4
--- /dev/null
+++ b/src/PLib.Domain/Videos/AppliedMetadataSource.cs
@@ -0,0 +1,38 @@
+namespace PLib.Domain.Videos;
+
+/// <summary>
+/// A record that one metadata source's answer was written onto a video.
+/// </summary>
+/// <remarks>
+/// A set rather than a single "last applied" field, because the question a run asks is per
+/// source: this video already has what PornDB knows, so ask StashDB and leave PornDB alone.
+/// One field would answer that only until a second source was applied, after which the first
+/// would be forgotten and offered all over again.
+/// </remarks>
+public sealed class AppliedMetadataSource
+{
+    /// <summary>Required by EF Core materialization; do not use from application code.</summary>
+    private AppliedMetadataSource() => SourceName = null!;
+
+    public AppliedMetadataSource(string sourceName, DateTimeOffset appliedAt)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(sourceName);
+
+        SourceName = sourceName.Trim();
+        AppliedAt = appliedAt;
+    }
+
+    /// <summary>The configured source's name, as the user wrote it in the settings.</summary>
+    public string SourceName { get; private set; }
+
+    public DateTimeOffset AppliedAt { get; private set; }
+
+    /// <summary>
+    /// Matched case-insensitively: the name is free text the user typed, and "PornDb" and
+    /// "PornDB" are plainly the same source to everyone but a byte comparison.
+    /// </summary>
+    public bool Is(string sourceName) =>
+        string.Equals(SourceName, sourceName?.Trim(), StringComparison.CurrentCultureIgnoreCase);
+
+    internal void RefreshedAt(DateTimeOffset appliedAt) => AppliedAt = appliedAt;
+}
diff --git a/src/PLib.Domain/Videos/VideoItem.cs b/src/PLib.Domain/Videos/VideoItem.cs
index ff12be2..859d324 100644
--- a/src/PLib.Domain/Videos/VideoItem.cs
+++ b/src/PLib.Domain/Videos/VideoItem.cs
@@ -1,258 +1,295 @@
-namespace PLib.Domain.Videos;
-
-/// <summary>
-/// A single video file that belongs to the library.
-/// </summary>
-/// <remarks>
-/// The absolute path is the natural identity of a video: the library is a view over the
-/// file system, so two entries pointing at the same path are the same video. Mutation goes
-/// through explicit methods so that the entity can never end up half-updated.
-/// </remarks>
-public sealed class VideoItem
-{
-    /// <summary>
-    /// How close to the end counts as finished. Credits and trailing black frames mean a
-    /// video is done well before its last millisecond, and offering to resume there is worse
-    /// than offering nothing.
-    /// </summary>
-    private static readonly TimeSpan EndOfPlaybackSlack = TimeSpan.FromSeconds(15);
-
-    /// <summary>Below this, the viewer barely started; resuming would be noise.</summary>
-    private static readonly TimeSpan ResumeThreshold = TimeSpan.FromSeconds(20);
-
-    private readonly List<LibraryLabel> _labels = [];
-
-    /// <summary>Required by EF Core materialization; do not use from application code.</summary>
-    private VideoItem()
-    {
-        FullPath = null!;
-        Title = null!;
-    }
-
-    public VideoItem(string fullPath, string title, long sizeInBytes, DateTimeOffset fileModifiedAt)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(fullPath);
-        ArgumentException.ThrowIfNullOrWhiteSpace(title);
-        ArgumentOutOfRangeException.ThrowIfNegative(sizeInBytes);
-
-        Id = Guid.CreateVersion7();
-        FullPath = fullPath;
-        Title = title;
-        SizeInBytes = sizeInBytes;
-        FileModifiedAt = fileModifiedAt;
-        AddedAt = DateTimeOffset.UtcNow;
-    }
-
-    public Guid Id { get; private set; }
-
-    /// <summary>Absolute path of the file on disk. Unique within the library.</summary>
-    public string FullPath { get; private set; }
-
-    /// <summary>Human readable name; defaults to the file name without extension.</summary>
-    public string Title { get; private set; }
-
-    /// <summary>
-    /// Free text about the video. Never derived from the file — it only arrives from a
-    /// metadata source or from the user, which is why refreshing the file leaves it alone.
-    /// </summary>
-    public string? Description { get; private set; }
-
-    public long SizeInBytes { get; private set; }
-
-    public TimeSpan? Duration { get; private set; }
-
-    public int? Width { get; private set; }
-
-    public int? Height { get; private set; }
-
-    public string? VideoCodec { get; private set; }
-
-    /// <summary>Absolute path of the generated poster frame, or <c>null</c> if none exists yet.</summary>
-    public string? ThumbnailPath { get; private set; }
-
-    /// <summary>
-    /// Absolute path of the animated preview — frames sampled across the video and stacked
-    /// into one image — or <c>null</c> if it has not been rendered yet.
-    /// </summary>
-    public string? PreviewPath { get; private set; }
-
-    /// <summary>
-    /// How many frames <see cref="PreviewPath"/> holds. Stored rather than assumed, because
-    /// the setting that produced it can change while old previews stay on disk, and a strip
-    /// sliced by the wrong count animates as a jumble.
-    /// </summary>
-    public int PreviewFrameCount { get; private set; }
-
-    /// <summary>Last write time of the file when it was last indexed.</summary>
-    public DateTimeOffset FileModifiedAt { get; private set; }
-
-    public DateTimeOffset AddedAt { get; private set; }
-
-    /// <summary>
-    /// Where playback stopped last time, or <c>null</c> when there is nothing worth
-    /// resuming — never watched, barely started, or watched to the end.
-    /// </summary>
-    public TimeSpan? ResumePosition { get; private set; }
-
-    public DateTimeOffset? LastPlayedAt { get; private set; }
-
-    /// <summary>How many times the video was watched through to the end.</summary>
-    public int PlayCount { get; private set; }
-
-    /// <summary>
-    /// Perceptual hash of the video's visuals, or <c>null</c> if it has not been computed.
-    /// Compared by Hamming distance rather than for equality.
-    /// </summary>
-    public ulong? PerceptualHash { get; private set; }
-
-    /// <summary>Tags and collections this video belongs to.</summary>
-    public IReadOnlyCollection<LibraryLabel> Labels => _labels;
-
-    /// <summary>
-    /// True once the file has been probed and a poster frame produced — everything the grid
-    /// needs. The perceptual hash is deliberately not part of this: it costs far more than
-    /// the rest put together and is computed in a pass of its own, after the cards are
-    /// already on screen.
-    /// </summary>
-    public bool IsIndexed => Duration is not null && ThumbnailPath is not null;
-
-    /// <summary>
-    /// True when the animated preview is still to be rendered. Like hashing, it samples the
-    /// running time and therefore cannot start before the duration is known.
-    /// </summary>
-    public bool NeedsAnimatedPreview => Duration is not null && PreviewPath is null;
-
-    /// <summary>
-    /// True when the video is ready to be hashed but has not been. Hashing samples frames
-    /// across the running time, so it cannot start before the duration is known.
-    /// </summary>
-    public bool NeedsPerceptualHash => Duration is not null && PerceptualHash is null;
-
-    /// <summary>How far through the video the viewer got, as a fraction, for the card overlay.</summary>
-    public double WatchedFraction => Duration is { TotalSeconds: > 0 } total && ResumePosition is { } position
-        ? Math.Clamp(position / total, 0, 1)
-        : 0;
-
-    public void Rename(string title)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(title);
-        Title = title;
-    }
-
-    /// <summary>Replaces the description; blank clears it rather than storing whitespace.</summary>
-    public void Describe(string? description) =>
-        Description = string.IsNullOrWhiteSpace(description) ? null : description.Trim();
-
-    public void ApplyTechnicalInfo(VideoTechnicalInfo info)
-    {
-        Duration = info.Duration;
-        Width = info.Width;
-        Height = info.Height;
-        VideoCodec = info.VideoCodec;
-    }
-
-    /// <summary>
-    /// Records where playback stopped. A position at either extreme is stored as "nothing to
-    /// resume": too early to matter, or close enough to the end that the video counts as
-    /// watched — which is also the only place <see cref="PlayCount"/> goes up.
-    /// </summary>
-    public void RememberProgress(TimeSpan position)
-    {
-        LastPlayedAt = DateTimeOffset.UtcNow;
-
-        if (position < ResumeThreshold)
-        {
-            ResumePosition = null;
-            return;
-        }
-
-        if (Duration is { } duration && position >= duration - EndOfPlaybackSlack)
-        {
-            MarkWatched();
-            return;
-        }
-
-        ResumePosition = position;
-    }
-
-    public void MarkWatched()
-    {
-        ResumePosition = null;
-        LastPlayedAt = DateTimeOffset.UtcNow;
-        PlayCount++;
-    }
-
-    public bool AddLabel(LibraryLabel label)
-    {
-        ArgumentNullException.ThrowIfNull(label);
-
-        if (_labels.Any(existing => existing.Id == label.Id))
-        {
-            return false;
-        }
-
-        _labels.Add(label);
-        return true;
-    }
-
-    public bool RemoveLabel(Guid labelId) => _labels.RemoveAll(label => label.Id == labelId) > 0;
-
-    public void ApplyPerceptualHash(ulong? hash) => PerceptualHash = hash;
-
-    /// <summary>
-    /// How many bits differ from another video's hash, or <c>null</c> when either side has
-    /// no hash to compare.
-    /// </summary>
-    public int? DistanceTo(VideoItem other)
-    {
-        ArgumentNullException.ThrowIfNull(other);
-
-        return PerceptualHash is { } mine && other.PerceptualHash is { } theirs
-            ? System.Numerics.BitOperations.PopCount(mine ^ theirs)
-            : null;
-    }
-
-    public void AttachThumbnail(string thumbnailPath)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(thumbnailPath);
-        ThumbnailPath = thumbnailPath;
-    }
-
-    public void DetachThumbnail() => ThumbnailPath = null;
-
-    public void AttachPreview(string previewPath, int frameCount)
-    {
-        ArgumentException.ThrowIfNullOrWhiteSpace(previewPath);
-        ArgumentOutOfRangeException.ThrowIfLessThan(frameCount, 2);
-
-        PreviewPath = previewPath;
-        PreviewFrameCount = frameCount;
-    }
-
-    public void DetachPreview()
-    {
-        PreviewPath = null;
-        PreviewFrameCount = 0;
-    }
-
-    /// <summary>
-    /// Refreshes the file system facts after the file changed on disk, and invalidates
-    /// everything that was derived from the previous revision of the file.
-    /// </summary>
-    public void RefreshFileFacts(long sizeInBytes, DateTimeOffset fileModifiedAt)
-    {
-        ArgumentOutOfRangeException.ThrowIfNegative(sizeInBytes);
-
-        if (SizeInBytes == sizeInBytes && FileModifiedAt == fileModifiedAt)
-        {
-            return;
-        }
-
-        SizeInBytes = sizeInBytes;
-        FileModifiedAt = fileModifiedAt;
-        ApplyTechnicalInfo(VideoTechnicalInfo.Unknown);
-        ApplyPerceptualHash(null);
-        DetachThumbnail();
-        DetachPreview();
-    }
-}
+namespace PLib.Domain.Videos;
+
+/// <summary>
+/// A single video file that belongs to the library.
+/// </summary>
+/// <remarks>
+/// The absolute path is the natural identity of a video: the library is a view over the
+/// file system, so two entries pointing at the same path are the same video. Mutation goes
+/// through explicit methods so that the entity can never end up half-updated.
+/// </remarks>
+public sealed class VideoItem
+{
+    /// <summary>
+    /// How close to the end counts as finished. Credits and trailing black frames mean a
+    /// video is done well before its last millisecond, and offering to resume there is worse
+    /// than offering nothing.
+    /// </summary>
+    private static readonly TimeSpan EndOfPlaybackSlack = TimeSpan.FromSeconds(15);
+
+    /// <summary>Below this, the viewer barely started; resuming would be noise.</summary>
+    private static readonly TimeSpan ResumeThreshold = TimeSpan.FromSeconds(20);
+
+    private readonly List<LibraryLabel> _labels = [];
+    private readonly List<AppliedMetadataSource> _appliedSources = [];
+
+    /// <summary>Required by EF Core materialization; do not use from application code.</summary>
+    private VideoItem()
+    {
+        FullPath = null!;
+        Title = null!;
+    }
+
+    public VideoItem(string fullPath, string title, long sizeInBytes, DateTimeOffset fileModifiedAt)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(fullPath);
+        ArgumentException.ThrowIfNullOrWhiteSpace(title);
+        ArgumentOutOfRangeException.ThrowIfNegative(sizeInBytes);
+
+        Id = Guid.CreateVersion7();
+        FullPath = fullPath;
+        Title = title;
+        SizeInBytes = sizeInBytes;
+        FileModifiedAt = fileModifiedAt;
+        AddedAt = DateTimeOffset.UtcNow;
+    }
+
+    public Guid Id { get; private set; }
+
+    /// <summary>Absolute path of the file on disk. Unique within the library.</summary>
+    public string FullPath { get; private set; }
+
+    /// <summary>Human readable name; defaults to the file name without extension.</summary>
+    public string Title { get; private set; }
+
+    /// <summary>
+    /// Free text about the video. Never derived from the file — it only arrives from a
+    /// metadata source or from the user, which is why refreshing the file leaves it alone.
+    /// </summary>
+    public string? Description { get; private set; }
+
+    /// <summary>
+    /// Which metadata sources have had an answer written onto this video, and when.
+    /// </summary>
+    /// <remarks>
+    /// Recorded in its own right rather than inferred from the description. A source that has
+    /// a title, performers and tags but no synopsis leaves the description empty, and taking
+    /// that to mean "never matched" is what made such videos come back on every run.
+    /// </remarks>
+    public IReadOnlyCollection<AppliedMetadataSource> AppliedSources => _appliedSources;
+
+    public long SizeInBytes { get; private set; }
+
+    public TimeSpan? Duration { get; private set; }
+
+    public int? Width { get; private set; }
+
+    public int? Height { get; private set; }
+
+    public string? VideoCodec { get; private set; }
+
+    /// <summary>Absolute path of the generated poster frame, or <c>null</c> if none exists yet.</summary>
+    public string? ThumbnailPath { get; private set; }
+
+    /// <summary>
+    /// Absolute path of the animated preview — frames sampled across the video and stacked
+    /// into one image — or <c>null</c> if it has not been rendered yet.
+    /// </summary>
+    public string? PreviewPath { get; private set; }
+
+    /// <summary>
+    /// How many frames <see cref="PreviewPath"/> holds. Stored rather than assumed, because
+    /// the setting that produced it can change while old previews stay on disk, and a strip
+    /// sliced by the wrong count animates as a jumble.
+    /// </summary>
+    public int PreviewFrameCount { get; private set; }
+
+    /// <summary>Last write time of the file when it was last indexed.</summary>
+    public DateTimeOffset FileModifiedAt { get; private set; }
+
+    public DateTimeOffset AddedAt { get; private set; }
+
+    /// <summary>
+    /// Where playback stopped last time, or <c>null</c> when there is nothing worth
+    /// resuming — never watched, barely started, or watched to the end.
+    /// </summary>
+    public TimeSpan? ResumePosition { get; private set; }
+
+    public DateTimeOffset? LastPlayedAt { get; private set; }
+
+    /// <summary>How many times the video was watched through to the end.</summary>
+    public int PlayCount { get; private set; }
+
+    /// <summary>
+    /// Perceptual hash of the video's visuals, or <c>null</c> if it has not been computed.
+    /// Compared by Hamming distance rather than for equality.
+    /// </summary>
+    public ulong? PerceptualHash { get; private set; }
+
+    /// <summary>Tags and collections this video belongs to.</summary>
+    public IReadOnlyCollection<LibraryLabel> Labels => _labels;
+
+    /// <summary>
+    /// True once the file has been probed and a poster frame produced — everything the grid
+    /// needs. The perceptual hash is deliberately not part of this: it costs far more than
+    /// the rest put together and is computed in a pass of its own, after the cards are
+    /// already on screen.
+    /// </summary>
+    public bool IsIndexed => Duration is not null && ThumbnailPath is not null;
+
+    /// <summary>
+    /// True when the animated preview is still to be rendered. Like hashing, it samples the
+    /// running time and therefore cannot start before the duration is known.
+    /// </summary>
+    public bool NeedsAnimatedPreview => Duration is not null && PreviewPath is null;
+
+    /// <summary>
+    /// True when the video is ready to be hashed but has not been. Hashing samples frames
+    /// across the running time, so it cannot start before the duration is known.
+    /// </summary>
+    public bool NeedsPerceptualHash => Duration is not null && PerceptualHash is null;
+
+    /// <summary>How far through the video the viewer got, as a fraction, for the card overlay.</summary>
+    public double WatchedFraction => Duration is { TotalSeconds: > 0 } total && ResumePosition is { } position
+        ? Math.Clamp(position / total, 0, 1)
+        : 0;
+
+    public void Rename(string title)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(title);
+        Title = title;
+    }
+
+    /// <summary>True once any source's answer has been written onto this video.</summary>
+    public bool HasMetadata => _appliedSources.Count > 0;
+
+    /// <summary>True when this particular source has already had its say.</summary>
+    public bool HasMetadataFrom(string sourceName) =>
+        _appliedSources.Any(applied => applied.Is(sourceName));
+
+    /// <summary>Records that a match from <paramref name="sourceName"/> was written on.</summary>
+    public void MarkMetadataApplied(string sourceName)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(sourceName);
+
+        // Re-applying the same source moves its timestamp rather than adding a second entry:
+        // the set answers "has this source had its say", and twice is the same as once.
+        if (_appliedSources.FirstOrDefault(applied => applied.Is(sourceName)) is { } existing)
+        {
+            existing.RefreshedAt(DateTimeOffset.UtcNow);
+            return;
+        }
+
+        _appliedSources.Add(new AppliedMetadataSource(sourceName, DateTimeOffset.UtcNow));
+    }
+
+    /// <summary>Replaces the description; blank clears it rather than storing whitespace.</summary>
+    public void Describe(string? description) =>
+        Description = string.IsNullOrWhiteSpace(description) ? null : description.Trim();
+
+    public void ApplyTechnicalInfo(VideoTechnicalInfo info)
+    {
+        Duration = info.Duration;
+        Width = info.Width;
+        Height = info.Height;
+        VideoCodec = info.VideoCodec;
+    }
+
+    /// <summary>
+    /// Records where playback stopped. A position at either extreme is stored as "nothing to
+    /// resume": too early to matter, or close enough to the end that the video counts as
+    /// watched — which is also the only place <see cref="PlayCount"/> goes up.
+    /// </summary>
+    public void RememberProgress(TimeSpan position)
+    {
+        LastPlayedAt = DateTimeOffset.UtcNow;
+
+        if (position < ResumeThreshold)
+        {
+            ResumePosition = null;
+            return;
+        }
+
+        if (Duration is { } duration && position >= duration - EndOfPlaybackSlack)
+        {
+            MarkWatched();
+            return;
+        }
+
+        ResumePosition = position;
+    }
+
+    public void MarkWatched()
+    {
+        ResumePosition = null;
+        LastPlayedAt = DateTimeOffset.UtcNow;
+        PlayCount++;
+    }
+
+    public bool AddLabel(LibraryLabel label)
+    {
+        ArgumentNullException.ThrowIfNull(label);
+
+        if (_labels.Any(existing => existing.Id == label.Id))
+        {
+            return false;
+        }
+
+        _labels.Add(label);
+        return true;
+    }
+
+    public bool RemoveLabel(Guid labelId) => _labels.RemoveAll(label => label.Id == labelId) > 0;
+
+    public void ApplyPerceptualHash(ulong? hash) => PerceptualHash = hash;
+
+    /// <summary>
+    /// How many bits differ from another video's hash, or <c>null</c> when either side has
+    /// no hash to compare.
+    /// </summary>
+    public int? DistanceTo(VideoItem other)
+    {
+        ArgumentNullException.ThrowIfNull(other);
+
+        return PerceptualHash is { } mine && other.PerceptualHash is { } theirs
+            ? System.Numerics.BitOperations.PopCount(mine ^ theirs)
+            : null;
+    }
+
+    public void AttachThumbnail(string thumbnailPath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(thumbnailPath);
+        ThumbnailPath = thumbnailPath;
+    }
+
+    public void DetachThumbnail() => ThumbnailPath = null;
+
+    public void AttachPreview(string previewPath, int frameCount)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(previewPath);
+        ArgumentOutOfRangeException.ThrowIfLessThan(frameCount, 2);
+
+        PreviewPath = previewPath;
+        PreviewFrameCount = frameCount;
+    }
+
+    public void DetachPreview()
+    {
+        PreviewPath = null;
+        PreviewFrameCount = 0;
+    }
+
+    /// <summary>
+    /// Refreshes the file system facts after the file changed on disk, and invalidates
+    /// everything that was derived from the previous revision of the file.
+    /// </summary>
+    public void RefreshFileFacts(long sizeInBytes, DateTimeOffset fileModifiedAt)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(sizeInBytes);
+
+        if (SizeInBytes == sizeInBytes && FileModifiedAt == fileModifiedAt)
+        {
+            return;
+        }
+
+        SizeInBytes = sizeInBytes;
+        FileModifiedAt = fileModifiedAt;
+        ApplyTechnicalInfo(VideoTechnicalInfo.Unknown);
+        ApplyPerceptualHash(null);
+        DetachThumbnail();
+        DetachPreview();
+
+        // The fingerprint that earned those answers described the previous file.
+        _appliedSources.Clear();
+    }
+}
diff --git a/src/PLib.Infrastructure/Persistence/EfVideoRepository.cs b/src/PLib.Infrastructure/Persistence/EfVideoRepository.cs
index 95d2a35..c8aa0d8 100644
--- a/src/PLib.Infrastructure/Persistence/EfVideoRepository.cs
+++ b/src/PLib.Infrastructure/Persistence/EfVideoRepository.cs
@@ -1,44 +1,55 @@
-using Microsoft.EntityFrameworkCore;
-using PLib.Application.Abstractions;
-using PLib.Domain.Videos;
-
-namespace PLib.Infrastructure.Persistence;
-
-/// <inheritdoc cref="IVideoRepository"/>
-public sealed class EfVideoRepository(LibraryDbContext dbContext) : IVideoRepository
-{
-    public async Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default) =>
-        await dbContext.Videos
-            .OrderByDescending(x => x.AddedAt)
-            .ToListAsync(cancellationToken);
-
-    public async Task<IReadOnlyList<VideoItem>> GetAllWithLabelsAsync(
-        CancellationToken cancellationToken = default) =>
-        await dbContext.Videos
-            .Include(x => x.Labels)
-            // Split: with the join in one query every video row would come back once per
-            // label, and the rows are wide enough for that to cost real time on a big library.
-            .AsSplitQuery()
-            .OrderByDescending(x => x.AddedAt)
-            .ToListAsync(cancellationToken);
-
-    public Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default) =>
-        dbContext.Videos.FirstOrDefaultAsync(x => x.FullPath == fullPath, cancellationToken);
-
-    public Task<VideoItem?> FindWithLabelsAsync(Guid id, CancellationToken cancellationToken = default) =>
-        dbContext.Videos
-            .Include(x => x.Labels)
-            .FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
-
-    public async Task AddAsync(VideoItem item, CancellationToken cancellationToken = default) =>
-        await dbContext.Videos.AddAsync(item, cancellationToken);
-
-    public Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default)
-    {
-        dbContext.Videos.Remove(item);
-        return Task.CompletedTask;
-    }
-
-    public Task SaveChangesAsync(CancellationToken cancellationToken = default) =>
-        dbContext.SaveChangesAsync(cancellationToken);
-}
+using Microsoft.EntityFrameworkCore;
+using PLib.Application.Abstractions;
+using PLib.Domain.Videos;
+
+namespace PLib.Infrastructure.Persistence;
+
+/// <inheritdoc cref="IVideoRepository"/>
+public sealed class EfVideoRepository(LibraryDbContext dbContext) : IVideoRepository
+{
+    public async Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default) =>
+        await dbContext.Videos
+            .OrderByDescending(x => x.AddedAt)
+            .ToListAsync(cancellationToken);
+
+    public async Task<IReadOnlyList<VideoItem>> GetAllWithLabelsAsync(
+        CancellationToken cancellationToken = default) =>
+        await dbContext.Videos
+            .Include(x => x.Labels)
+            // Split: with the join in one query every video row would come back once per
+            // label, and the rows are wide enough for that to cost real time on a big library.
+            .AsSplitQuery()
+            .OrderByDescending(x => x.AddedAt)
+            .ToListAsync(cancellationToken);
+
+    public async Task<IReadOnlyList<VideoItem>> GetAllWithMetadataSourcesAsync(
+        CancellationToken cancellationToken = default) =>
+        await dbContext.Videos
+            .Include(x => x.AppliedSources)
+            .OrderByDescending(x => x.AddedAt)
+            .ToListAsync(cancellationToken);
+
+    public Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default) =>
+        dbContext.Videos.FirstOrDefaultAsync(x => x.FullPath == fullPath, cancellationToken);
+
+    public Task<VideoItem?> FindWithLabelsAsync(Guid id, CancellationToken cancellationToken = default) =>
+        dbContext.Videos
+            .Include(x => x.Labels)
+
+            // Applying a match writes here too, and without the collection loaded EF would
+            // add a second row for a source that has already had its say.
+            .Include(x => x.AppliedSources)
+            .FirstOrDefaultAsync(x => x.Id == id, cancellationToken);
+
+    public async Task AddAsync(VideoItem item, CancellationToken cancellationToken = default) =>
+        await dbContext.Videos.AddAsync(item, cancellationToken);
+
+    public Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default)
+    {
+        dbContext.Videos.Remove(item);
+        return Task.CompletedTask;
+    }
+
+    public Task SaveChangesAsync(CancellationToken cancellationToken = default) =>
+        dbContext.SaveChangesAsync(cancellationToken);
+}
diff --git a/src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.Designer.cs b/src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.Designer.cs
new file mode 100644
index 0000000..c02ddf7
--- /dev/null
+++ b/src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.Designer.cs
@@ -0,0 +1,176 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using PLib.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace PLib.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(LibraryDbContext))]
+    [Migration("20260810080601_MetadataApplied")]
+    partial class MetadataApplied
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
+
+            modelBuilder.Entity("LibraryLabelVideoItem", b =>
+                {
+                    b.Property<Guid>("LabelsId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("VideosId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LabelsId", "VideosId");
+
+                    b.HasIndex("VideosId");
+
+                    b.ToTable("VideoLabels", (string)null);
+                });
+
+            modelBuilder.Entity("PLib.Domain.Videos.LibraryLabel", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("CreatedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ImagePath")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Kind", "NormalizedName")
+                        .IsUnique();
+
+                    b.ToTable("Labels", (string)null);
+                });
+
+            modelBuilder.Entity("PLib.Domain.Videos.VideoItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("AddedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeSpan?>("Duration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("FileModifiedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FullPath")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("LastPlayedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("MetadataAppliedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MetadataSource")
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("PerceptualHash")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PreviewFrameCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreviewPath")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeSpan?>("ResumePosition")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("SizeInBytes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ThumbnailPath")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("VideoCodec")
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AddedAt");
+
+                    b.HasIndex("FullPath")
+                        .IsUnique();
+
+                    b.HasIndex("LastPlayedAt");
+
+                    b.HasIndex("PerceptualHash");
+
+                    b.ToTable("Videos", (string)null);
+                });
+
+            modelBuilder.Entity("LibraryLabelVideoItem", b =>
+                {
+                    b.HasOne("PLib.Domain.Videos.LibraryLabel", null)
+                        .WithMany()
+                        .HasForeignKey("LabelsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PLib.Domain.Videos.VideoItem", null)
+                        .WithMany()
+                        .HasForeignKey("VideosId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.cs b/src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.cs
new file mode 100644
index 0000000..1aaaf54
--- /dev/null
+++ b/src/PLib.Infrastructure/Persistence/Migrations/20260810080601_MetadataApplied.cs
@@ -0,0 +1,51 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PLib.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class MetadataApplied : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<long>(
+                name: "MetadataAppliedAt",
+                table: "Videos",
+                type: "INTEGER",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "MetadataSource",
+                table: "Videos",
+                type: "TEXT",
+                maxLength: 128,
+                nullable: true);
+
+            // Videos matched before this column existed would otherwise all look untouched and
+            // be offered again on the next run. A description is the only trace such a match
+            // left behind, so it stands in for one — the timestamp is "now" in .NET ticks,
+            // which is the unix epoch plus 62135596800 seconds. The source stays unknown,
+            // because it genuinely is.
+            migrationBuilder.Sql(
+                """
+                UPDATE "Videos"
+                SET "MetadataAppliedAt" = (strftime('%s', 'now') + 62135596800) * 10000000
+                WHERE "Description" IS NOT NULL AND trim("Description") <> ''
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "MetadataAppliedAt",
+                table: "Videos");
+
+            migrationBuilder.DropColumn(
+                name: "MetadataSource",
+                table: "Videos");
+        }
+    }
+}
diff --git a/src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.Designer.cs b/src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.Designer.cs
new file mode 100644
index 0000000..86137af
--- /dev/null
+++ b/src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.Designer.cs
@@ -0,0 +1,202 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using PLib.Infrastructure.Persistence;
+
+#nullable disable
+
+namespace PLib.Infrastructure.Persistence.Migrations
+{
+    [DbContext(typeof(LibraryDbContext))]
+    [Migration("20260810082839_AppliedMetadataSources")]
+    partial class AppliedMetadataSources
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
+
+            modelBuilder.Entity("LibraryLabelVideoItem", b =>
+                {
+                    b.Property<Guid>("LabelsId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("VideosId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("LabelsId", "VideosId");
+
+                    b.HasIndex("VideosId");
+
+                    b.ToTable("VideoLabels", (string)null);
+                });
+
+            modelBuilder.Entity("PLib.Domain.Videos.LibraryLabel", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("CreatedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ImagePath")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("NormalizedName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Kind", "NormalizedName")
+                        .IsUnique();
+
+                    b.ToTable("Labels", (string)null);
+                });
+
+            modelBuilder.Entity("PLib.Domain.Videos.VideoItem", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("AddedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeSpan?>("Duration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("FileModifiedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FullPath")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("LastPlayedAt")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("PerceptualHash")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PreviewFrameCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreviewPath")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeSpan?>("ResumePosition")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("SizeInBytes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ThumbnailPath")
+                        .HasMaxLength(1024)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("VideoCodec")
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AddedAt");
+
+                    b.HasIndex("FullPath")
+                        .IsUnique();
+
+                    b.HasIndex("LastPlayedAt");
+
+                    b.HasIndex("PerceptualHash");
+
+                    b.ToTable("Videos", (string)null);
+                });
+
+            modelBuilder.Entity("LibraryLabelVideoItem", b =>
+                {
+                    b.HasOne("PLib.Domain.Videos.LibraryLabel", null)
+                        .WithMany()
+                        .HasForeignKey("LabelsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("PLib.Domain.Videos.VideoItem", null)
+                        .WithMany()
+                        .HasForeignKey("VideosId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("PLib.Domain.Videos.VideoItem", b =>
+                {
+                    b.OwnsMany("PLib.Domain.Videos.AppliedMetadataSource", "AppliedSources", b1 =>
+                        {
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<long>("AppliedAt")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<string>("SourceName")
+                                .IsRequired()
+                                .HasMaxLength(128)
+                                .HasColumnType("TEXT");
+
+                            b1.Property<Guid>("VideoId")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("Id");
+
+                            b1.HasIndex("VideoId", "SourceName")
+                                .IsUnique();
+
+                            b1.ToTable("VideoMetadataSources", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("VideoId");
+                        });
+
+                    b.Navigation("AppliedSources");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.cs b/src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.cs
new file mode 100644
index 0000000..7ba8170
--- /dev/null
+++ b/src/PLib.Infrastructure/Persistence/Migrations/20260810082839_AppliedMetadataSources.cs
@@ -0,0 +1,98 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace PLib.Infrastructure.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class AppliedMetadataSources : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Deliberately reordered from what was scaffolded: the generated version dropped
+            // the two columns first and created the table afterwards, which would have thrown
+            // away every record of what had already been applied.
+            migrationBuilder.CreateTable(
+                name: "VideoMetadataSources",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "INTEGER", nullable: false)
+                        .Annotation("Sqlite:Autoincrement", true),
+                    SourceName = table.Column<string>(type: "TEXT", maxLength: 128, nullable: false),
+                    AppliedAt = table.Column<long>(type: "INTEGER", nullable: false),
+                    VideoId = table.Column<Guid>(type: "TEXT", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_VideoMetadataSources", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_VideoMetadataSources_Videos_VideoId",
+                        column: x => x.VideoId,
+                        principalTable: "Videos",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_VideoMetadataSources_VideoId_SourceName",
+                table: "VideoMetadataSources",
+                columns: new[] { "VideoId", "SourceName" },
+                unique: true);
+
+            // The single-source column becomes the first row of the set. Rows that recorded a
+            // time but no name came from the previous migration's backfill, which inferred the
+            // fact from a description and genuinely could not know the source.
+            migrationBuilder.Sql(
+                """
+                INSERT INTO "VideoMetadataSources" ("VideoId", "SourceName", "AppliedAt")
+                SELECT "Id", COALESCE(NULLIF(trim("MetadataSource"), ''), 'неизвестный источник'), "MetadataAppliedAt"
+                FROM "Videos"
+                WHERE "MetadataAppliedAt" IS NOT NULL
+                """);
+
+            migrationBuilder.DropColumn(
+                name: "MetadataAppliedAt",
+                table: "Videos");
+
+            migrationBuilder.DropColumn(
+                name: "MetadataSource",
+                table: "Videos");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<long>(
+                name: "MetadataAppliedAt",
+                table: "Videos",
+                type: "INTEGER",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "MetadataSource",
+                table: "Videos",
+                type: "TEXT",
+                maxLength: 128,
+                nullable: true);
+
+            // Going back keeps the most recent source of each video; the rest cannot fit.
+            migrationBuilder.Sql(
+                """
+                UPDATE "Videos"
+                SET "MetadataAppliedAt" = (
+                        SELECT max("AppliedAt") FROM "VideoMetadataSources" AS "s"
+                        WHERE "s"."VideoId" = "Videos"."Id"),
+                    "MetadataSource" = (
+                        SELECT "s"."SourceName" FROM "VideoMetadataSources" AS "s"
+                        WHERE "s"."VideoId" = "Videos"."Id"
+                        ORDER BY "s"."AppliedAt" DESC LIMIT 1)
+                WHERE EXISTS (SELECT 1 FROM "VideoMetadataSources" AS "s" WHERE "s"."VideoId" = "Videos"."Id")
+                """);
+
+            migrationBuilder.DropTable(
+                name: "VideoMetadataSources");
+        }
+    }
+}
diff --git a/src/PLib.Infrastructure/Persistence/Migrations/LibraryDbContextModelSnapshot.cs b/src/PLib.Infrastructure/Persistence/Migrations/LibraryDbContextModelSnapshot.cs
index ed2ed69..aa58066 100644
--- a/src/PLib.Infrastructure/Persistence/Migrations/LibraryDbContextModelSnapshot.cs
+++ b/src/PLib.Infrastructure/Persistence/Migrations/LibraryDbContextModelSnapshot.cs
@@ -160,6 +160,39 @@ namespace PLib.Infrastructure.Persistence.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
                 });
+
+            modelBuilder.Entity("PLib.Domain.Videos.VideoItem", b =>
+                {
+                    b.OwnsMany("PLib.Domain.Videos.AppliedMetadataSource", "AppliedSources", b1 =>
+                        {
+                            b1.Property<int>("Id")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<long>("AppliedAt")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<string>("SourceName")
+                                .IsRequired()
+                                .HasMaxLength(128)
+                                .HasColumnType("TEXT");
+
+                            b1.Property<Guid>("VideoId")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("Id");
+
+                            b1.HasIndex("VideoId", "SourceName")
+                                .IsUnique();
+
+                            b1.ToTable("VideoMetadataSources", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("VideoId");
+                        });
+
+                    b.Navigation("AppliedSources");
+                });
 #pragma warning restore 612, 618
         }
     }
diff --git a/src/PLib.Infrastructure/Persistence/VideoItemConfiguration.cs b/src/PLib.Infrastructure/Persistence/VideoItemConfiguration.cs
index 4d623fc..816a576 100644
--- a/src/PLib.Infrastructure/Persistence/VideoItemConfiguration.cs
+++ b/src/PLib.Infrastructure/Persistence/VideoItemConfiguration.cs
@@ -1,78 +1,93 @@
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
-using PLib.Domain.Videos;
-
-namespace PLib.Infrastructure.Persistence;
-
-internal sealed class VideoItemConfiguration : IEntityTypeConfiguration<VideoItem>
-{
-    /// <summary>
-    /// SQLite refuses to ORDER BY a DateTimeOffset because its default TEXT representation
-    /// carries an offset and therefore does not sort chronologically. Storing UTC ticks keeps
-    /// the column both sortable and indexable.
-    /// </summary>
-    private static readonly ValueConverter<DateTimeOffset, long> UtcTicksConverter = new(
-        value => value.UtcTicks,
-        ticks => new DateTimeOffset(ticks, TimeSpan.Zero));
-
-    private static readonly ValueConverter<DateTimeOffset?, long?> NullableUtcTicksConverter = new(
-        value => value == null ? null : value.Value.UtcTicks,
-        ticks => ticks == null ? null : new DateTimeOffset(ticks.Value, TimeSpan.Zero));
-
-    public void Configure(EntityTypeBuilder<VideoItem> builder)
-    {
-        builder.ToTable("Videos");
-
-        builder.HasKey(x => x.Id);
-
-        builder.Property(x => x.AddedAt).HasConversion(UtcTicksConverter);
-        builder.Property(x => x.FileModifiedAt).HasConversion(UtcTicksConverter);
-        builder.Property(x => x.LastPlayedAt).HasConversion(NullableUtcTicksConverter);
-
-        // SQLite integers are signed, so the hash is stored as its bit pattern rather than
-        // its value — reinterpreted, never converted, so no bits are lost either way.
-        builder.Property(x => x.PerceptualHash).HasConversion(
-            hash => hash == null ? (long?)null : unchecked((long)hash.Value),
-            stored => stored == null ? (ulong?)null : unchecked((ulong)stored.Value));
-
-        // Exact matches are the cheap half of duplicate detection and worth an index.
-        builder.HasIndex(x => x.PerceptualHash);
-
-        builder.Property(x => x.FullPath)
-            .IsRequired()
-            .HasMaxLength(1024);
-
-        builder.HasIndex(x => x.FullPath)
-            .IsUnique();
-
-        builder.Property(x => x.Title)
-            .IsRequired()
-            .HasMaxLength(512);
-
-        // Unbounded on purpose: a synopsis from a metadata source has no natural ceiling, and
-        // truncating one silently is worse than storing it whole.
-        builder.Property(x => x.Description);
-
-        builder.Property(x => x.VideoCodec)
-            .HasMaxLength(64);
-
-        builder.Property(x => x.ThumbnailPath)
-            .HasMaxLength(1024);
-
-        builder.Property(x => x.PreviewPath)
-            .HasMaxLength(1024);
-
-        // Sorting the grid by "recently added" is the default view, so it gets an index.
-        builder.HasIndex(x => x.AddedAt);
-
-        // All computed from other columns, and none of them may become table columns.
-        builder.Ignore(x => x.IsIndexed);
-        builder.Ignore(x => x.NeedsAnimatedPreview);
-        builder.Ignore(x => x.NeedsPerceptualHash);
-        builder.Ignore(x => x.WatchedFraction);
-
-        // "Continue watching" and "recently played" are both ordered by this.
-        builder.HasIndex(x => x.LastPlayedAt);
-    }
-}
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using PLib.Domain.Videos;
+
+namespace PLib.Infrastructure.Persistence;
+
+internal sealed class VideoItemConfiguration : IEntityTypeConfiguration<VideoItem>
+{
+    /// <summary>
+    /// SQLite refuses to ORDER BY a DateTimeOffset because its default TEXT representation
+    /// carries an offset and therefore does not sort chronologically. Storing UTC ticks keeps
+    /// the column both sortable and indexable.
+    /// </summary>
+    private static readonly ValueConverter<DateTimeOffset, long> UtcTicksConverter = new(
+        value => value.UtcTicks,
+        ticks => new DateTimeOffset(ticks, TimeSpan.Zero));
+
+    private static readonly ValueConverter<DateTimeOffset?, long?> NullableUtcTicksConverter = new(
+        value => value == null ? null : value.Value.UtcTicks,
+        ticks => ticks == null ? null : new DateTimeOffset(ticks.Value, TimeSpan.Zero));
+
+    public void Configure(EntityTypeBuilder<VideoItem> builder)
+    {
+        builder.ToTable("Videos");
+
+        builder.HasKey(x => x.Id);
+
+        builder.Property(x => x.AddedAt).HasConversion(UtcTicksConverter);
+        builder.Property(x => x.FileModifiedAt).HasConversion(UtcTicksConverter);
+        builder.Property(x => x.LastPlayedAt).HasConversion(NullableUtcTicksConverter);
+        // Owned, not a separate aggregate: an applied source has no life of its own and
+        // is only ever read through the video it was applied to.
+        builder.OwnsMany(x => x.AppliedSources, applied =>
+        {
+            applied.ToTable("VideoMetadataSources");
+            applied.WithOwner().HasForeignKey("VideoId");
+            applied.Property<int>("Id");
+            applied.HasKey("Id");
+
+            applied.Property(x => x.SourceName).IsRequired().HasMaxLength(128);
+            applied.Property(x => x.AppliedAt).HasConversion(UtcTicksConverter);
+
+            // One row per source per video; re-applying moves the timestamp.
+            applied.HasIndex("VideoId", nameof(AppliedMetadataSource.SourceName)).IsUnique();
+        });
+
+        // SQLite integers are signed, so the hash is stored as its bit pattern rather than
+        // its value — reinterpreted, never converted, so no bits are lost either way.
+        builder.Property(x => x.PerceptualHash).HasConversion(
+            hash => hash == null ? (long?)null : unchecked((long)hash.Value),
+            stored => stored == null ? (ulong?)null : unchecked((ulong)stored.Value));
+
+        // Exact matches are the cheap half of duplicate detection and worth an index.
+        builder.HasIndex(x => x.PerceptualHash);
+
+        builder.Property(x => x.FullPath)
+            .IsRequired()
+            .HasMaxLength(1024);
+
+        builder.HasIndex(x => x.FullPath)
+            .IsUnique();
+
+        builder.Property(x => x.Title)
+            .IsRequired()
+            .HasMaxLength(512);
+
+        // Unbounded on purpose: a synopsis from a metadata source has no natural ceiling, and
+        // truncating one silently is worse than storing it whole.
+        builder.Property(x => x.Description);
+
+        builder.Property(x => x.VideoCodec)
+            .HasMaxLength(64);
+
+        builder.Property(x => x.ThumbnailPath)
+            .HasMaxLength(1024);
+
+        builder.Property(x => x.PreviewPath)
+            .HasMaxLength(1024);
+
+        // Sorting the grid by "recently added" is the default view, so it gets an index.
+        builder.HasIndex(x => x.AddedAt);
+
+        // All computed from other columns, and none of them may become table columns.
+        builder.Ignore(x => x.IsIndexed);
+        builder.Ignore(x => x.NeedsAnimatedPreview);
+        builder.Ignore(x => x.NeedsPerceptualHash);
+        builder.Ignore(x => x.WatchedFraction);
+
+        // "Continue watching" and "recently played" are both ordered by this.
+        builder.HasIndex(x => x.LastPlayedAt);
+    }
+}
diff --git a/tests/PLib.Tests/Library/InMemoryVideoRepository.cs b/tests/PLib.Tests/Library/InMemoryVideoRepository.cs
index f5a7ec7..b5e44d1 100644
--- a/tests/PLib.Tests/Library/InMemoryVideoRepository.cs
+++ b/tests/PLib.Tests/Library/InMemoryVideoRepository.cs
@@ -1,58 +1,62 @@
-using PLib.Application.Abstractions;
-using PLib.Application.Library;
-using PLib.Domain.Videos;
-
-namespace PLib.Tests.Library;
-
-/// <summary>
-/// A hand-written double rather than a mock: the scan logic is all about what ends up in the
-/// repository, so the tests read better when they can just look at the resulting list.
-/// </summary>
-internal sealed class InMemoryVideoRepository : IVideoRepository
-{
-    private readonly Dictionary<string, VideoItem> _items = new(LibraryPathComparer.Instance);
-
-    public int SaveCount { get; private set; }
-
-    public IReadOnlyCollection<VideoItem> Items => _items.Values;
-
-    public void Seed(params VideoItem[] items)
-    {
-        foreach (var item in items)
-        {
-            _items[item.FullPath] = item;
-        }
-    }
-
-    public Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default) =>
-        Task.FromResult<IReadOnlyList<VideoItem>>([.. _items.Values]);
-
-    // Labels are held on the entity itself here, so this is the same list.
-    public Task<IReadOnlyList<VideoItem>> GetAllWithLabelsAsync(CancellationToken cancellationToken = default) =>
-        GetAllAsync(cancellationToken);
-
-    public Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default) =>
-        Task.FromResult(_items.GetValueOrDefault(fullPath));
-
-    // Labels are held on the entity itself here, so there is nothing extra to load.
-    public Task<VideoItem?> FindWithLabelsAsync(Guid id, CancellationToken cancellationToken = default) =>
-        Task.FromResult(_items.Values.FirstOrDefault(item => item.Id == id));
-
-    public Task AddAsync(VideoItem item, CancellationToken cancellationToken = default)
-    {
-        _items[item.FullPath] = item;
-        return Task.CompletedTask;
-    }
-
-    public Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default)
-    {
-        _items.Remove(item.FullPath);
-        return Task.CompletedTask;
-    }
-
-    public Task SaveChangesAsync(CancellationToken cancellationToken = default)
-    {
-        SaveCount++;
-        return Task.CompletedTask;
-    }
-}
+using PLib.Application.Abstractions;
+using PLib.Application.Library;
+using PLib.Domain.Videos;
+
+namespace PLib.Tests.Library;
+
+/// <summary>
+/// A hand-written double rather than a mock: the scan logic is all about what ends up in the
+/// repository, so the tests read better when they can just look at the resulting list.
+/// </summary>
+internal sealed class InMemoryVideoRepository : IVideoRepository
+{
+    private readonly Dictionary<string, VideoItem> _items = new(LibraryPathComparer.Instance);
+
+    public int SaveCount { get; private set; }
+
+    public IReadOnlyCollection<VideoItem> Items => _items.Values;
+
+    public void Seed(params VideoItem[] items)
+    {
+        foreach (var item in items)
+        {
+            _items[item.FullPath] = item;
+        }
+    }
+
+    public Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default) =>
+        Task.FromResult<IReadOnlyList<VideoItem>>([.. _items.Values]);
+
+    // Labels are held on the entity itself here, so this is the same list.
+    public Task<IReadOnlyList<VideoItem>> GetAllWithLabelsAsync(CancellationToken cancellationToken = default) =>
+        GetAllAsync(cancellationToken);
+
+    // Applied sources live on the entity here, so this is the same list again.
+    public Task<IReadOnlyList<VideoItem>> GetAllWithMetadataSourcesAsync(CancellationToken cancellationToken = default) =>
+        GetAllAsync(cancellationToken);
+
+    public Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default) =>
+        Task.FromResult(_items.GetValueOrDefault(fullPath));
+
+    // Labels are held on the entity itself here, so there is nothing extra to load.
+    public Task<VideoItem?> FindWithLabelsAsync(Guid id, CancellationToken cancellationToken = default) =>
+        Task.FromResult(_items.Values.FirstOrDefault(item => item.Id == id));
+
+    public Task AddAsync(VideoItem item, CancellationToken cancellationToken = default)
+    {
+        _items[item.FullPath] = item;
+        return Task.CompletedTask;
+    }
+
+    public Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default)
+    {
+        _items.Remove(item.FullPath);
+        return Task.CompletedTask;
+    }
+
+    public Task SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        SaveCount++;
+        return Task.CompletedTask;
+    }
+}
diff --git a/tests/PLib.Tests/Library/MetadataScanTests.cs b/tests/PLib.Tests/Library/MetadataScanTests.cs
index f132d10..711eb02 100644
--- a/tests/PLib.Tests/Library/MetadataScanTests.cs
+++ b/tests/PLib.Tests/Library/MetadataScanTests.cs
@@ -39,21 +39,57 @@ public sealed class MetadataScanTests
     }
 
     [Fact]
-    public async Task Videos_that_already_have_a_description_are_skipped_by_default()
+    public async Task Videos_a_match_was_already_applied_to_are_skipped_by_default()
     {
-        var described = Video("описанное", hash: 1);
-        described.Describe("уже есть");
-        _videos.Seed(described, Video("голое", hash: 2));
+        var done = Video("размеченное", hash: 1);
+        done.MarkMetadataApplied("StashDB");
+        _videos.Seed(done, Video("голое", hash: 2));
 
         Answer(_source, []);
 
         (await CollectAsync()).OfType<MetadataScanEvent.Completed>().Single().Processed.ShouldBe(1);
 
         // Asking again for everything is what the switch is for.
-        var all = await CollectAsync(new MetadataScanRequest(OnlyWithoutDescription: false));
+        var all = await CollectAsync(new MetadataScanRequest(OnlyWithoutMetadata: false));
         all.OfType<MetadataScanEvent.Completed>().Single().Processed.ShouldBe(2);
     }
 
+    [Fact]
+    public async Task A_match_with_no_synopsis_still_counts_as_applied()
+    {
+        var video = Video("видео", hash: 1);
+        _videos.Seed(video);
+
+        // stash-box scenes often carry a title, performers and tags but no details at all.
+        Answer(_source, [Match("Название") with { Description = null }]);
+
+        await CollectAsync(new MetadataScanRequest(ApplyUnambiguous: true));
+
+        video.Description.ShouldBeNull();
+        video.MetadataAppliedAt.ShouldNotBeNull();
+        video.MetadataSource.ShouldBe("StashDB");
+
+        // Judging "already done" by the description sent these back on every single run.
+        var again = await CollectAsync(new MetadataScanRequest(ApplyUnambiguous: true));
+        again.OfType<MetadataScanEvent.Completed>().Single().Processed.ShouldBe(0);
+    }
+
+    [Fact]
+    public async Task A_result_carries_our_own_poster_frame_for_the_user_to_compare_against()
+    {
+        var video = Video("видео", hash: 1);
+        video.AttachThumbnail(@"C:\cache\ours.jpg");
+        _videos.Seed(video);
+
+        Answer(_source, [Match("Название")]);
+
+        var matched = (await CollectAsync()).OfType<MetadataScanEvent.Matched>().Single();
+
+        // Deciding whether a proposal is the same video is done by eye, and there is nothing
+        // to judge against if only the proposals have pictures.
+        matched.VideoThumbnailPath.ShouldBe(@"C:\cache\ours.jpg");
+    }
+
     [Fact]
     public async Task A_single_candidate_is_written_only_when_the_run_was_told_it_may()
     {