Compare each side of a data source edit with its own provider

app/MindWork AI Studio/Tools/DataSourceReindexWarning.cs

@@ -72,14 +72,23 @@ public static class DataSourceReindexWarning
         IInternalDataSource before, IInternalDataSource after, CancellationToken token = default)
     {
         // Without a provider nothing is embedded at all, so nothing can be lost:
-        if (!DataSourceEmbeddingProviders.TryResolve(settingsManager, after, out var embeddingProvider))
+        if (!DataSourceEmbeddingProviders.TryResolve(settingsManager, after, out var afterProvider))
             return true;
 
-        if (!EmbeddingChangeImpact.AffectsStoredIndex(embeddingProvider, before, after))
+        //
+        // The provider a data source points at today may be gone -- somebody deleted it, and this
+        // edit is how the source is put back to work. Standing in for it with NONE gives a signature
+        // of its own, so that edit is asked about as well, which is right: what is stored was made by
+        // a provider nobody can reach any more.
+        //
+        DataSourceEmbeddingProviders.TryResolve(settingsManager, before, out var resolvedBeforeProvider);
+        var beforeProvider = resolvedBeforeProvider ?? EmbeddingProvider.NONE;
+
+        if (!EmbeddingChangeImpact.AffectsStoredIndex(before, beforeProvider, after, afterProvider))
             return true;
 
         var affected = await embeddingService.GetDataSourcesWithStoredIndexAsync([after], token);
-        return await ConfirmAsync(dialogService, affected, !embeddingProvider.IsSelfHosted);
+        return await ConfirmAsync(dialogService, affected, !afterProvider.IsSelfHosted);
     }
 
     /// <summary>

app/MindWork AI Studio/Tools/Services/EmbeddingChangeImpact.cs

@@ -28,13 +28,20 @@ internal static class EmbeddingChangeImpact
     /// <summary>
     /// Whether an edited data source invalidates what is stored for it.
     /// </summary>
-    /// <param name="embeddingProvider">The embedding provider, which the edit leaves alone.</param>
+    /// <remarks>
+    /// Each side is asked with the embedding provider it points at, never both with the same one. A
+    /// data source carries only the id of its provider, while the signature carries what that provider
+    /// is, so comparing both sides against one of them would report a changed embedding as no change
+    /// at all -- and the next indexing run would then rebuild everything unannounced.
+    /// </remarks>
     /// <param name="before">The data source as it is stored.</param>
+    /// <param name="beforeProvider">The embedding provider it points at today.</param>
     /// <param name="after">The data source as it would be stored.</param>
+    /// <param name="afterProvider">The embedding provider it would point at.</param>
     /// <returns>True when the stored index would be discarded.</returns>
-    public static bool AffectsStoredIndex(EmbeddingProvider embeddingProvider, IDataSource before, IDataSource after) =>
+    public static bool AffectsStoredIndex(IDataSource before, EmbeddingProvider beforeProvider, IDataSource after, EmbeddingProvider afterProvider) =>
         !string.Equals(
-            DataSourceEmbeddingService.BuildEmbeddingSignature(before, embeddingProvider),
-            DataSourceEmbeddingService.BuildEmbeddingSignature(after, embeddingProvider),
+            DataSourceEmbeddingService.BuildEmbeddingSignature(before, beforeProvider),
+            DataSourceEmbeddingService.BuildEmbeddingSignature(after, afterProvider),
             StringComparison.Ordinal);
 }