feat(job-search): read providers from DB and suppress link when none enabled

JobTokenService.CreateTokenAsync queries cvSearch.JobProviders for any
enabled row; returns null (no token created) when the table is empty or
all providers are disabled. TriggerStartAsync snapshots enabled providers
from DB at session-start time, preserving the existing snapshot contract.

CvMatcherController guards link-building on a non-null TokenId so the
"Start a job search" CTA is omitted from match emails when no providers
are configured.

JobSearchSettings.Providers list removed — provider config now lives
exclusively in the DB. CvSearchJobTask.GetProviders falls back to an
empty list with a warning (snapshot should always be populated from DB).

Closes #35

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Apis/api/Controllers/CvMatcherController.cs

@@ -183,8 +183,11 @@ public sealed class CvMatcherController : ControllerBase
                     var tokenResp = await _jobSearchApi.CreateTokenAsync(
                         new CreateJobSearchTokenRequest { CvDocumentId = request.CvDocumentId, Email = request.Email, Language = language },
                         ct);
-                    var baseUrl = _jobSearchLinkSettings.BaseUrl.TrimEnd('/');
+                    if (!string.IsNullOrWhiteSpace(tokenResp.TokenId))
-                    jobSearchLink = $"{baseUrl}/api/cv-matcher/job-search/start?t={tokenResp.TokenId}";
+                    {
+                        var baseUrl = _jobSearchLinkSettings.BaseUrl.TrimEnd('/');
+                        jobSearchLink = $"{baseUrl}/api/cv-matcher/job-search/start?t={tokenResp.TokenId}";
+                    }
                 }
                 catch (Exception ex)
                 {

Apis/cv-matcher-api-models/Responses/CreateJobSearchTokenResponse.cs

@@ -2,5 +2,9 @@ namespace CvMatcher.Models.Responses;
 
 public sealed class CreateJobSearchTokenResponse
 {
-    public string TokenId { get; set; } = string.Empty;
+    /// <summary>
+    /// The generated token ID, or <c>null</c> when no job providers are currently enabled.
+    /// Callers must check for null before building the job-search link.
+    /// </summary>
+    public string? TokenId { get; set; }
 }

Apis/cv-matcher-api-models/Settings/JobSearchSettings.cs

@@ -7,9 +7,12 @@ public sealed class JobSearchSettings
     public int TokenExpiryDays { get; set; } = 7;
     public int MinMatchScore { get; set; } = 15;
     public int MaxJobsToMatch { get; set; } = 15;
-    public List<JobProviderConfig> Providers { get; set; } = [];
 }
 
+/// <summary>
+/// Runtime DTO for a job provider. Populated from <c>cvSearch.JobProviders</c> at session-creation
+/// time and snapshotted to <c>JobSearchSessionEntity.ProviderConfigJson</c>.
+/// </summary>
 public sealed class JobProviderConfig
 {
     public string Name { get; set; } = string.Empty;

Apis/cv-matcher-api/Services/Contracts/IJobTokenService.cs

@@ -13,8 +13,11 @@ public interface IJobTokenService
     /// <param name="email">Email address of the user who will receive the results.</param>
     /// <param name="language">Preferred language for result emails (e.g. <c>"en"</c>, <c>"ro"</c>).</param>
     /// <param name="ct">Cancellation token.</param>
-    /// <returns>The generated token ID, to be embedded in the one-click job search link.</returns>
+    /// <returns>
-    Task<string> CreateTokenAsync(string cvDocumentId, string email, string language, CancellationToken ct);
+    /// The generated token ID to embed in the one-click job search link,
+    /// or <c>null</c> when no job providers are currently enabled (link should be suppressed).
+    /// </returns>
+    Task<string?> CreateTokenAsync(string cvDocumentId, string email, string language, CancellationToken ct);
 
     /// <summary>
     /// Validates the token and, if valid, marks it as used and creates a <c>Pending</c> job search session.

Apis/cv-matcher-api/Services/JobTokenService.cs

@@ -13,6 +13,9 @@ namespace Api.Services;
 
 /// <summary>
 /// Creates and validates one-time job search tokens, and creates the corresponding search sessions.
+/// Provider configuration is read from <c>cvSearch.JobProviders</c> at session-creation time and
+/// snapshotted into <c>JobSearchSessionEntity.ProviderConfigJson</c> so subsequent config changes
+/// do not affect already-queued sessions.
 /// </summary>
 public sealed class JobTokenService : IJobTokenService
 {
@@ -34,8 +37,15 @@ public sealed class JobTokenService : IJobTokenService
     }
 
     /// <inheritdoc />
-    public async Task<string> CreateTokenAsync(string cvDocumentId, string email, string language, CancellationToken ct)
+    public async Task<string?> CreateTokenAsync(string cvDocumentId, string email, string language, CancellationToken ct)
     {
+        var hasEnabledProviders = await _db.JobProviders.AnyAsync(p => p.Enabled, ct);
+        if (!hasEnabledProviders)
+        {
+            _logger.LogDebug("Job search token skipped — no enabled providers in cvSearch.JobProviders");
+            return null;
+        }
+
         var token = new JobSearchTokenEntity
         {
             Id = Guid.NewGuid().ToString("N"),
@@ -67,8 +77,13 @@ public sealed class JobTokenService : IJobTokenService
         var cv = await _rag.GetDocumentAsync(token.CvDocumentId, ct);
         var keywords = cv is not null ? ExtractKeywords(cv.Text) : string.Empty;
 
+        var enabledProviders = await _db.JobProviders
+            .Where(p => p.Enabled)
+            .OrderBy(p => p.DisplayOrder)
+            .ToListAsync(ct);
+
         var providerConfigJson = JsonSerializer.Serialize(
-            _settings.Providers.Where(p => p.Enabled).ToList(),
+            enabledProviders.Select(ToConfig).ToList(),
             new JsonSerializerOptions(JsonSerializerDefaults.Web));
 
         var session = new JobSearchSessionEntity
@@ -86,11 +101,41 @@ public sealed class JobTokenService : IJobTokenService
 
         _db.JobSearchSessions.Add(session);
         await _db.SaveChangesAsync(ct);
-        _logger.LogInformation("Job search session created. SessionId={SessionId}, Keywords={Keywords}", session.Id, keywords);
+        _logger.LogInformation(
+            "Job search session created. SessionId={SessionId}, Keywords={Keywords}, Providers={Providers}",
+            session.Id, keywords, string.Join(", ", enabledProviders.Select(p => p.Name)));
 
         return StartJobSearchStatus.Started;
     }
 
+    /// <summary>
+    /// Maps a <see cref="JobProviderEntity"/> to the <see cref="JobProviderConfig"/> DTO used by
+    /// <c>cv-search-job</c>. The <c>InitialKeywords</c> list is stored as a JSON array in the entity.
+    /// </summary>
+    private static JobProviderConfig ToConfig(JobProviderEntity entity)
+    {
+        List<string> keywords;
+        try
+        {
+            keywords = JsonSerializer.Deserialize<List<string>>(entity.InitialKeywordsJson,
+                new JsonSerializerOptions(JsonSerializerDefaults.Web)) ?? [];
+        }
+        catch
+        {
+            keywords = [];
+        }
+
+        return new JobProviderConfig
+        {
+            Name = entity.Name,
+            Enabled = entity.Enabled,
+            SearchUrlTemplate = entity.SearchUrlTemplate,
+            JobLinkContains = entity.JobLinkContains,
+            InitialKeywords = keywords,
+            MaxResults = entity.MaxResults
+        };
+    }
+
     /// <summary>
     /// Extracts up to 10 meaningful keywords from the CV text using simple heuristics (no LLM).
     /// Takes the first 5 usable lines, splits them into words, strips punctuation, and deduplicates.

Apis/cv-search-data/Data/CvSearchDbContext.cs

@@ -13,6 +13,7 @@ public sealed class CvSearchDbContext : DbContext
     public DbSet<JobSearchTokenEntity> JobSearchTokens => Set<JobSearchTokenEntity>();
     public DbSet<JobSearchSessionEntity> JobSearchSessions => Set<JobSearchSessionEntity>();
     public DbSet<JobSearchResultEntity> JobSearchResults => Set<JobSearchResultEntity>();
+    public DbSet<JobProviderEntity> JobProviders => Set<JobProviderEntity>();
 
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
     {
@@ -65,5 +66,18 @@ public sealed class CvSearchDbContext : DbContext
             entity.Property(x => x.CreatedAt).HasDefaultValueSql("SYSUTCDATETIME()");
             entity.HasIndex(x => x.SessionId);
         });
+
+        modelBuilder.Entity<JobProviderEntity>(entity =>
+        {
+            entity.ToTable("JobProviders");
+            entity.HasKey(x => x.Id);
+            entity.Property(x => x.Id).UseIdentityColumn();
+            entity.Property(x => x.Name).HasMaxLength(128).IsRequired();
+            entity.Property(x => x.SearchUrlTemplate).HasMaxLength(1024).IsRequired();
+            entity.Property(x => x.JobLinkContains).HasMaxLength(256).IsRequired();
+            entity.Property(x => x.InitialKeywordsJson).HasMaxLength(2000).HasDefaultValue("[]").IsRequired();
+            entity.Property(x => x.MaxResults).HasDefaultValue(20);
+            entity.Property(x => x.DisplayOrder).HasDefaultValue(0);
+        });
     }
 }

Apis/cv-search-data/Data/Entities/JobProviderEntity.cs

@@ -0,0 +1,33 @@
+namespace CvSearch.Data.Entities;
+
+/// <summary>
+/// Persisted job-board provider configuration. Stored in <c>cvSearch.JobProviders</c>.
+/// Providers are loaded from here at session-creation time and snapshotted into
+/// <c>JobSearchSessionEntity.ProviderConfigJson</c> so runtime config changes do not
+/// affect already-queued sessions.
+/// </summary>
+public sealed class JobProviderEntity
+{
+    public int Id { get; set; }
+
+    /// <summary>Display name (e.g. "ejobs.ro").</summary>
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>When false the provider is skipped at session-creation and the job-search link is hidden.</summary>
+    public bool Enabled { get; set; }
+
+    /// <summary>URL template with <c>{keywords}</c> placeholder (URL-encoded keywords are substituted at runtime).</summary>
+    public string SearchUrlTemplate { get; set; } = string.Empty;
+
+    /// <summary>Substring that must appear in an anchor href to pass the stage-1 link filter.</summary>
+    public string JobLinkContains { get; set; } = string.Empty;
+
+    /// <summary>JSON array of baseline keywords merged with CV keywords before building the search URL.</summary>
+    public string InitialKeywordsJson { get; set; } = "[]";
+
+    /// <summary>Maximum number of job URLs to collect from this provider per session.</summary>
+    public int MaxResults { get; set; } = 20;
+
+    /// <summary>Controls display ordering in future admin UIs.</summary>
+    public int DisplayOrder { get; set; }
+}

Apis/cv-search-data/Migrations/20260529084440_AddJobProviders.Designer.cs

@@ -0,0 +1,222 @@
+// <auto-generated />
+using System;
+using CvSearch.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace CvSearch.Data.Migrations
+{
+    [DbContext(typeof(CvSearchDbContext))]
+    [Migration("20260529084440_AddJobProviders")]
+    partial class AddJobProviders
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasDefaultSchema("cvSearch")
+                .HasAnnotation("ProductVersion", "10.0.7")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("CvSearch.Data.Entities.JobProviderEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DisplayOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("InitialKeywordsJson")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)")
+                        .HasDefaultValue("[]");
+
+                    b.Property<string>("JobLinkContains")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<int>("MaxResults")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(20);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.Property<string>("SearchUrlTemplate")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("nvarchar(1024)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JobProviders", "cvSearch");
+                });
+
+            modelBuilder.Entity("CvSearch.Data.Entities.JobSearchResultEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("SYSUTCDATETIME()");
+
+                    b.Property<string>("JobText")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("JobTitle")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("nvarchar(512)");
+
+                    b.Property<string>("JobUrl")
+                        .IsRequired()
+                        .HasMaxLength(2048)
+                        .HasColumnType("nvarchar(2048)");
+
+                    b.Property<string>("ProviderName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.Property<string>("ResultJson")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("Score")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SessionId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SessionId");
+
+                    b.ToTable("JobSearchResults", "cvSearch");
+                });
+
+            modelBuilder.Entity("CvSearch.Data.Entities.JobSearchSessionEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("SYSUTCDATETIME()");
+
+                    b.Property<string>("CvDocumentId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("Keywords")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(8)
+                        .HasColumnType("nvarchar(8)")
+                        .HasDefaultValue("en");
+
+                    b.Property<string>("ProviderConfigJson")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.Property<string>("TokenId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status");
+
+                    b.ToTable("JobSearchSessions", "cvSearch");
+                });
+
+            modelBuilder.Entity("CvSearch.Data.Entities.JobSearchTokenEntity", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("datetime2")
+                        .HasDefaultValueSql("SYSUTCDATETIME()");
+
+                    b.Property<string>("CvDocumentId")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<DateTime>("ExpiresAt")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Language")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(8)
+                        .HasColumnType("nvarchar(8)")
+                        .HasDefaultValue("en");
+
+                    b.Property<bool>("Used")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JobSearchTokens", "cvSearch");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Apis/cv-search-data/Migrations/20260529084440_AddJobProviders.cs

@@ -0,0 +1,55 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace CvSearch.Data.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddJobProviders : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "JobProviders",
+                schema: "cvSearch",
+                columns: table => new
+                {
+                    Id = table.Column<int>(type: "int", nullable: false)
+                        .Annotation("SqlServer:Identity", "1, 1"),
+                    Name = table.Column<string>(type: "nvarchar(128)", maxLength: 128, nullable: false),
+                    Enabled = table.Column<bool>(type: "bit", nullable: false),
+                    SearchUrlTemplate = table.Column<string>(type: "nvarchar(1024)", maxLength: 1024, nullable: false),
+                    JobLinkContains = table.Column<string>(type: "nvarchar(256)", maxLength: 256, nullable: false),
+                    InitialKeywordsJson = table.Column<string>(type: "nvarchar(2000)", maxLength: 2000, nullable: false, defaultValue: "[]"),
+                    MaxResults = table.Column<int>(type: "int", nullable: false, defaultValue: 20),
+                    DisplayOrder = table.Column<int>(type: "int", nullable: false, defaultValue: 0)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_JobProviders", x => x.Id);
+                });
+
+            // Seed the three default providers — all disabled so the feature is opt-in per environment.
+            // Enable a provider by setting its Enabled column to 1 via SQL or a future admin UI.
+            migrationBuilder.InsertData(
+                schema: "cvSearch",
+                table: "JobProviders",
+                columns: ["Name", "Enabled", "SearchUrlTemplate", "JobLinkContains", "InitialKeywordsJson", "MaxResults", "DisplayOrder"],
+                values: new object[,]
+                {
+                    { "ejobs.ro",     false, "https://www.ejobs.ro/user/locuri-de-munca/?utm_source=myai&q={keywords}", "/user/locuri-de-munca/",      "[]", 20, 0 },
+                    { "bestjobs.eu",  false, "https://www.bestjobs.eu/ro/locuri-de-munca?keywords={keywords}",           "/ro/locuri-de-munca/",         "[]", 20, 1 },
+                    { "linkedin.com", false, "https://www.linkedin.com/jobs/search/?keywords={keywords}",                "/jobs/view/",                  "[]", 20, 2 },
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "JobProviders",
+                schema: "cvSearch");
+        }
+    }
+}

Apis/cv-search-data/Migrations/CvSearchDbContextModelSnapshot.cs

@@ -1,4 +1,4 @@
-// <auto-generated />
+// <auto-generated />
 using System;
 using CvSearch.Data;
 using Microsoft.EntityFrameworkCore;
@@ -23,6 +23,54 @@ namespace CvSearch.Data.Migrations
 
             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
 
+            modelBuilder.Entity("CvSearch.Data.Entities.JobProviderEntity", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("DisplayOrder")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("InitialKeywordsJson")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)")
+                        .HasDefaultValue("[]");
+
+                    b.Property<string>("JobLinkContains")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<int>("MaxResults")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(20);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.Property<string>("SearchUrlTemplate")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("nvarchar(1024)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JobProviders", "cvSearch");
+                });
+
             modelBuilder.Entity("CvSearch.Data.Entities.JobSearchResultEntity", b =>
                 {
                     b.Property<string>("Id")

Jobs/cv-search-job/Tasks/CvSearchJobTask.cs

@@ -204,20 +204,27 @@ public sealed class CvSearchJobTask : IJobTask
 
     /// <summary>
     /// Deserialises the provider configuration snapshot stored on the session.
-    /// Falls back to the current live config when the snapshot is absent or unparseable.
+    /// Providers are always snapshotted from the DB at session-creation time, so the snapshot
+    /// should always be present. Returns an empty list (with a warning) when it is missing or corrupt.
     /// </summary>
     private List<JobProviderConfig> GetProviders(string? providerConfigJson)
     {
-        if (string.IsNullOrWhiteSpace(providerConfigJson)) return _settings.Providers.Where(p => p.Enabled).ToList();
+        if (string.IsNullOrWhiteSpace(providerConfigJson))
+        {
+            _logger.LogWarning("Session has no provider config snapshot — returning empty provider list");
+            return [];
+        }
+
         try
         {
             return JsonSerializer.Deserialize<List<JobProviderConfig>>(providerConfigJson,
                        new JsonSerializerOptions(JsonSerializerDefaults.Web))
-                   ?? _settings.Providers.Where(p => p.Enabled).ToList();
+                   ?? [];
         }
-        catch
+        catch (Exception ex)
         {
-            return _settings.Providers.Where(p => p.Enabled).ToList();
+            _logger.LogWarning(ex, "Failed to deserialise provider config snapshot — returning empty provider list");
+            return [];
         }
     }