RF-aware load imbalance, exclude gateway-only consoles, fix AP tie-breaking (#512)

* RF-aware load imbalance rule, extend roaming topology to 72h

Load Imbalance: When APs are placed on the Signal Map, use RF propagation
modeling to check if the overloaded and underloaded APs are in separate
coverage zones. If they are distant and all clients on the busy AP have
strong signal, suppress the warning entirely. If distant but some clients
are weak, downgrade to Info. Hints users to place APs on the map when
propagation context isn't available.

Roaming Topology: Pass within=259200 (72h) to the UniFi roaming topology
API for a broader view of roaming failures instead of the default 24h.

* Exclude gateway-only consoles from Wi-Fi Optimizer, revert roaming to 24h

UDM-Pro, UDM-SE, UDM-Pro-Max, and EFG report radio_table entries in the
UniFi API but have no actual Wi-Fi radios. Filter them out using the
FriendlyModelName: exclude gateways starting with "UDM-" or equal to "EFG".
The original UDM (Dream Machine) passes through since it has real Wi-Fi.

Also reverts the roaming topology lookback from 72h back to the default 24h.

* Also exclude EFG-Core and future EFG variants from Wi-Fi Optimizer

* Fix load imbalance picking same AP for both max and min

When multiple APs have the same client count, OrderByDescending and
OrderBy could non-deterministically pick the same AP for both maxAp
and minAp, producing messages like "X has 8 clients while X has only 8".

Fix: use opposite MAC tie-breaking (ThenBy vs ThenByDescending) to
guarantee different APs, plus a MAC equality guard as a safety net.

* Add tests for load imbalance rule and gateway AP exclusion

LoadImbalanceRuleTests (13 tests):
- Basic threshold behavior (single AP, no clients, balanced, imbalanced)
- Tie-breaking: ensures maxAp != minAp when client counts are equal
- RF distance: suppressed when far apart + strong signal, Info when weak
- Propagation context edge cases (one AP not placed, null signal)

GatewayApExclusionTests (18 tests):
- UDM-Pro, UDM-SE, UDM-Pro-Max excluded (start with "UDM-")
- EFG and EFG-Core excluded (start with "EFG")
- UDM, UDR, UDR7, UX, UX7, UDW, UDR-5G-Max allowed (have real Wi-Fi)
- Device model/shortname values match real API responses

* Adjust AP radio card column widths in Wi-Fi Optimizer

* Adjust radio-channel width to 45px in AP cards

Author: tvancott42

src/NetworkOptimizer.UniFi/UniFiDiscovery.cs

@@ -126,14 +126,31 @@ public async Task<List<DiscoveredDevice>> DiscoverDevicesAsync(CancellationToken
     /// Discovers all devices with wireless radios for WiFi Optimizer.
     /// Includes traditional APs (type=uap), UDM/UX mesh APs, and gateway-class devices
     /// (UDR, UX, UDM) that have integrated wireless radios broadcasting Wi-Fi.
+    /// Excludes gateway-only consoles (UDM-Pro, UDM-SE, UDM-Pro-Max, EFG) that report
+    /// radio_table entries in the API but don't actually have Wi-Fi radios.
     /// SmartPower devices (USP-Strip, USP-Plug) are excluded via DeviceType classification.
     /// </summary>
     public async Task<List<DiscoveredDevice>> DiscoverAccessPointsAsync(CancellationToken cancellationToken = default)
     {
         var devices = await DiscoverDevicesAsync(cancellationToken);
         return devices.Where(d =>
             d.Type == DeviceType.AccessPoint ||
-            (d.Type == DeviceType.Gateway && d.RadioTable is { Count: > 0 })).ToList();
+            (d.Type == DeviceType.Gateway && d.RadioTable is { Count: > 0 } && !IsGatewayOnlyConsole(d))).ToList();
+    }
+
+    /// <summary>
+    /// Returns true for gateway-class consoles that do NOT have integrated Wi-Fi radios.
+    /// The UniFi API sometimes reports radio_table entries for these devices even though
+    /// they have no wireless capability. Uses FriendlyModelName (the UI display name)
+    /// as the source of truth rather than trusting API radio data.
+    /// Excludes: UDM-Pro, UDM-SE, UDM-Pro-Max (start with "UDM-"), EFG, EFG-Core (start with "EFG").
+    /// Allows: UDM (original Dream Machine), UDR, UX, etc. which have real Wi-Fi.
+    /// </summary>
+    internal static bool IsGatewayOnlyConsole(DiscoveredDevice device)
+    {
+        var name = device.FriendlyModelName;
+        return name.StartsWith("UDM-", StringComparison.OrdinalIgnoreCase) ||
+               name.StartsWith("EFG", StringComparison.OrdinalIgnoreCase);
     }
 
     /// <summary>

src/NetworkOptimizer.Web/wwwroot/css/app.css

@@ -7665,20 +7665,20 @@ a.path-hop.hop-clickable:hover {
 
 .radio-channel {
     color: var(--text-secondary);
-    width: 44px;
+    width: 45px;
     flex-shrink: 0;
 }
 
 .radio-eirp {
     color: var(--text-muted);
     font-size: 0.75rem;
-    width: 50px;
+    width: 47px;
     flex-shrink: 0;
 }
 
 .radio-util {
     font-weight: 500;
-    width: 58px;
+    width: 54px;
     flex-shrink: 0;
 }
 
@@ -7688,6 +7688,7 @@ a.path-hop.hop-clickable:hover {
 
 .radio-clients {
     color: var(--text-muted);
+    width: 60px;
     margin-left: auto;
 }
 

src/NetworkOptimizer.WiFi/Rules/LoadImbalanceRule.cs

@@ -1,20 +1,35 @@
 using NetworkOptimizer.WiFi.Models;
+using NetworkOptimizer.WiFi.Services;
 
 namespace NetworkOptimizer.WiFi.Rules;
 
 /// <summary>
 /// Rule that warns when there is significant load imbalance across APs,
 /// which can cause some APs to be overloaded while others are underutilized.
+/// Uses RF propagation modeling (when available) to suppress warnings for APs
+/// that are too far apart to share clients.
 /// </summary>
 public class LoadImbalanceRule : IWiFiOptimizerRule
 {
+    private readonly PropagationService _propagationService;
+
+    public LoadImbalanceRule(PropagationService propagationService)
+    {
+        _propagationService = propagationService;
+    }
+
     public string RuleId => "WIFI-LOAD-IMBALANCE-001";
 
     /// <summary>
     /// Coefficient of variation threshold (percentage) above which to warn.
     /// </summary>
     private const double ImbalanceThreshold = 50;
 
+    /// <summary>
+    /// Signal strength (dBm) at or above which a client is considered well-connected.
+    /// </summary>
+    private const int StrongSignalThreshold = -65;
+
     public HealthIssue? Evaluate(WiFiOptimizerContext ctx)
     {
         // Only relevant for multi-AP deployments
@@ -35,8 +50,94 @@ public class LoadImbalanceRule : IWiFiOptimizerRule
         if (imbalance < ImbalanceThreshold)
             return null;
 
-        var maxAp = ctx.AccessPoints.OrderByDescending(a => a.TotalClients).First();
-        var minAp = ctx.AccessPoints.OrderBy(a => a.TotalClients).First();
+        // Stable tie-breaking: when multiple APs have the same client count, use MAC to
+        // guarantee maxAp and minAp are different APs (opposite MAC sort direction).
+        var maxAp = ctx.AccessPoints.OrderByDescending(a => a.TotalClients).ThenBy(a => a.Mac).First();
+        var minAp = ctx.AccessPoints.OrderBy(a => a.TotalClients).ThenByDescending(a => a.Mac).First();
+
+        // Safety: if they resolved to the same AP (e.g., single AP after filtering), bail
+        if (maxAp.Mac.Equals(minAp.Mac, StringComparison.OrdinalIgnoreCase))
+            return null;
+
+        // RF distance check: if both APs are placed on the floor plan, use propagation
+        // modeling to determine if they're in separate coverage zones. If the APs are
+        // too far apart for clients to roam between them, load imbalance is expected.
+        if (ctx.PropagationContext != null)
+        {
+            var maxMac = maxAp.Mac.ToLowerInvariant();
+            var minMac = minAp.Mac.ToLowerInvariant();
+
+            if (ctx.PropagationContext.ApsByMac.TryGetValue(maxMac, out var maxProp) &&
+                ctx.PropagationContext.ApsByMac.TryGetValue(minMac, out var minProp))
+            {
+                // Check if the APs can reach each other on any common band.
+                // Use the same interference threshold as co-channel checks (-70 dBm).
+                var bands = new[] { "5", "2.4", "6" };
+                var apsInterfere = false;
+                foreach (var band in bands)
+                {
+                    // Only check bands both APs have active radios on
+                    var bandEnum = band switch
+                    {
+                        "2.4" => RadioBand.Band2_4GHz,
+                        "5" => RadioBand.Band5GHz,
+                        "6" => RadioBand.Band6GHz,
+                        _ => RadioBand.Band5GHz
+                    };
+                    if (!maxAp.Radios.Any(r => r.Band == bandEnum && r.Channel.HasValue) ||
+                        !minAp.Radios.Any(r => r.Band == bandEnum && r.Channel.HasValue))
+                        continue;
+
+                    if (_propagationService.DoApsInterfere(maxProp, minProp, band,
+                        ctx.PropagationContext.WallsByFloor, ctx.PropagationContext.Buildings))
+                    {
+                        apsInterfere = true;
+                        break;
+                    }
+                }
+
+                if (!apsInterfere)
+                {
+                    // APs are RF-distant (separate coverage zones) - imbalance is expected.
+                    // Additionally confirm: if clients on the overloaded AP all have strong
+                    // signals, they're well-placed and shouldn't be steered elsewhere.
+                    var clientsOnMaxAp = ctx.Clients
+                        .Where(c => c.ApMac.Equals(maxAp.Mac, StringComparison.OrdinalIgnoreCase))
+                        .ToList();
+
+                    var allStrongSignal = clientsOnMaxAp.Count > 0 &&
+                        clientsOnMaxAp.All(c => c.Signal.HasValue && c.Signal.Value >= StrongSignalThreshold);
+
+                    if (allStrongSignal)
+                    {
+                        // All clients on the busy AP have strong signal and the quiet AP is
+                        // far away - this is definitively a separate coverage zone, suppress entirely
+                        return null;
+                    }
+
+                    // APs are distant but some clients have weak signal - could indicate
+                    // a coverage gap rather than a load balancing issue. Downgrade to Info.
+                    return new HealthIssue
+                    {
+                        Severity = HealthIssueSeverity.Info,
+                        Dimensions = { HealthDimension.CapacityHeadroom },
+                        Title = "Significant Load Imbalance",
+                        Description = $"{maxAp.Name} has {maxAp.TotalClients} clients while {minAp.Name} has only {minAp.TotalClients}. " +
+                            $"These APs are in separate coverage zones so some imbalance is expected, " +
+                            $"but some clients on {maxAp.Name} have weak signal.",
+                        AffectedEntity = $"{maxAp.Name} ({maxAp.TotalClients}), {minAp.Name} ({minAp.TotalClients})",
+                        Recommendation = "Check if weak-signal clients on the busy AP could benefit from additional coverage in that zone.",
+                        ScoreImpact = -2
+                    };
+                }
+            }
+        }
+
+        var recommendation = "Consider lowering TX power on the overloaded AP or tightening minimum RSSI to encourage roaming to nearby APs.";
+
+        // Hint about floor plan placement if propagation context isn't available
+        if (ctx.PropagationContext == null)
+            recommendation += " Place your APs on the Signal Map to enable RF distance analysis - this issue may be suppressed if the APs are in separate coverage zones.";
 
         return new HealthIssue
         {
@@ -46,7 +147,7 @@ public class LoadImbalanceRule : IWiFiOptimizerRule
             Description = $"{maxAp.Name} has {maxAp.TotalClients} clients while {minAp.Name} has only {minAp.TotalClients}. " +
                 $"This imbalance ({imbalance:F0}%) can cause performance issues on overloaded APs.",
             AffectedEntity = $"{maxAp.Name} ({maxAp.TotalClients}), {minAp.Name} ({minAp.TotalClients})",
-            Recommendation = "Consider lowering TX power on the overloaded AP or tightening minimum RSSI to encourage roaming to nearby APs. This may be expected if these APs serve different coverage zones. No action needed unless clients have a stronger signal available from another AP.",
+            Recommendation = recommendation,
             ScoreImpact = -8
         };
     }

tests/NetworkOptimizer.UniFi.Tests/GatewayApExclusionTests.cs

@@ -0,0 +1,174 @@
+using FluentAssertions;
+using NetworkOptimizer.Core.Enums;
+using NetworkOptimizer.UniFi.Models;
+using Xunit;
+
+namespace NetworkOptimizer.UniFi.Tests;
+
+/// <summary>
+/// Tests that gateway-only consoles (no Wi-Fi radios) are excluded from the
+/// Wi-Fi Optimizer AP list, even when the UniFi API reports phantom radio_table entries.
+/// Device model/shortname values come from real API responses.
+/// </summary>
+public class GatewayApExclusionTests
+{
+    /// <summary>
+    /// Creates a DiscoveredDevice matching real UniFi API device response data.
+    /// Model and Shortname must match the production database so FriendlyModelName resolves correctly.
+    /// </summary>
+    private static DiscoveredDevice CreateGatewayDevice(
+        string model, string? shortname, int radioCount = 0)
+    {
+        var device = new DiscoveredDevice
+        {
+            Id = Guid.NewGuid().ToString(),
+            Mac = $"aa:bb:cc:{Guid.NewGuid().ToString()[..8]}",
+            Name = $"Test {shortname ?? model}",
+            Type = DeviceType.Gateway,
+            HardwareType = DeviceType.Gateway,
+            Model = model,
+            Shortname = shortname,
+            IpAddress = "192.0.2.1",
+            RadioTable = radioCount > 0
+                ? Enumerable.Range(0, radioCount).Select(i => new RadioTableEntry { Name = $"wifi{i}" }).ToList()
+                : null
+        };
+        return device;
+    }
+
+    // ---------------------------------------------------------------
+    // Gateway-only consoles: must be excluded even with radio_table
+    // ---------------------------------------------------------------
+
+    [Theory]
+    [InlineData("UDMPRO", "UDMPRO", "UDM-Pro")]          // Dream Machine Pro
+    [InlineData("UDMPROSE", "UDMPROSE", "UDM-SE")]        // Dream Machine SE
+    [InlineData("UDMPROMAX", "UDMPROMAX", "UDM-Pro-Max")] // Dream Machine Pro Max
+    public void UdmProFamily_Excluded(string model, string shortname, string expectedFriendlyName)
+    {
+        var device = CreateGatewayDevice(model, shortname, radioCount: 2);
+
+        device.FriendlyModelName.Should().Be(expectedFriendlyName,
+            $"model={model} shortname={shortname} should resolve to {expectedFriendlyName}");
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeTrue(
+            $"{expectedFriendlyName} has no Wi-Fi radios");
+    }
+
+    [Theory]
+    [InlineData("UDMENT", "UDMENT", "EFG")]   // Enterprise Fortress Gateway
+    [InlineData("EFG", "EFG", "EFG")]          // EFG via shortname alias
+    public void Efg_Excluded(string model, string shortname, string expectedFriendlyName)
+    {
+        var device = CreateGatewayDevice(model, shortname, radioCount: 2);
+
+        device.FriendlyModelName.Should().Be(expectedFriendlyName);
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeTrue(
+            $"{expectedFriendlyName} has no Wi-Fi radios");
+    }
+
+    [Fact]
+    public void EfgCore_ExcludedByPrefix()
+    {
+        // EFG-Core not yet in the product database, but FriendlyModelName would
+        // fall back to the shortname. Verify the StartsWith("EFG") prefix catches it.
+        var device = CreateGatewayDevice("EFGCORE", "EFG-Core", radioCount: 2);
+
+        // FriendlyModelName may be "EFG-Core" (from shortname fallback) or whatever the DB resolves
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeTrue(
+            "EFG-Core starts with 'EFG' and should be excluded");
+    }
+
+    [Theory]
+    [InlineData("UXGPRO", "UXGPRO")]     // Gateway Pro
+    [InlineData("UXGENT", "UXGENT")]      // Gateway Enterprise
+    [InlineData("UDMA6A8", "UCGF")]       // Cloud Gateway Fiber
+    [InlineData("UDRULT", "UDRULT")]      // UCG-Ultra
+    [InlineData("UXGB", "UXGB")]          // Gateway Max
+    public void OtherGatewayOnly_NotMatchedButNoRadios(string model, string shortname)
+    {
+        // These don't start with "UDM-" or "EFG" but also have no Wi-Fi.
+        // They're not caught by IsGatewayOnlyConsole, but they also won't
+        // have radio_table entries in the real API, so the RadioTable check
+        // in DiscoverAccessPointsAsync filters them out.
+        var device = CreateGatewayDevice(model, shortname, radioCount: 0);
+
+        // No radio_table → filtered by the Count > 0 check, not by IsGatewayOnlyConsole
+        device.RadioTable.Should().BeNull();
+    }
+
+    // ---------------------------------------------------------------
+    // Gateways WITH real Wi-Fi: must be allowed through
+    // ---------------------------------------------------------------
+
+    [Fact]
+    public void Udm_Allowed()
+    {
+        // Original Dream Machine - has real Wi-Fi radios
+        var device = CreateGatewayDevice("UDM", "UDM", radioCount: 2);
+
+        device.FriendlyModelName.Should().Be("UDM");
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeFalse(
+            "UDM (original Dream Machine) has integrated Wi-Fi");
+    }
+
+    [Fact]
+    public void Udr_Allowed()
+    {
+        // Dream Router - has real Wi-Fi radios
+        var device = CreateGatewayDevice("UDR", "UDR", radioCount: 2);
+
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeFalse(
+            "UDR has integrated Wi-Fi");
+    }
+
+    [Fact]
+    public void Udr7_Allowed()
+    {
+        // Dream Router 7 - has real Wi-Fi radios (from sample-device-resp-udr7.txt)
+        var device = CreateGatewayDevice("UDMA67A", "UDR7", radioCount: 3);
+
+        device.FriendlyModelName.Should().Be("UDR7");
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeFalse(
+            "UDR7 has integrated Wi-Fi");
+    }
+
+    [Fact]
+    public void Ux_Allowed()
+    {
+        // Express - has real Wi-Fi radios
+        var device = CreateGatewayDevice("UX", "UX", radioCount: 2);
+
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeFalse(
+            "UX (Express) has integrated Wi-Fi");
+    }
+
+    [Fact]
+    public void Ux7_Allowed()
+    {
+        // Express 7 - has real Wi-Fi radios
+        var device = CreateGatewayDevice("UDMA69B", "UX7", radioCount: 3);
+
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeFalse(
+            "UX7 (Express 7) has integrated Wi-Fi");
+    }
+
+    [Fact]
+    public void Udw_Allowed()
+    {
+        // Dream Wall - has real Wi-Fi radios
+        var device = CreateGatewayDevice("UDW", "UDW", radioCount: 3);
+
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeFalse(
+            "UDW (Dream Wall) has integrated Wi-Fi");
+    }
+
+    [Fact]
+    public void Udr5GMax_Allowed()
+    {
+        // Dream Router 5G Max - has real Wi-Fi radios
+        var device = CreateGatewayDevice("UDMA6B9", "UDR-5G-Max", radioCount: 3);
+
+        UniFiDiscovery.IsGatewayOnlyConsole(device).Should().BeFalse(
+            "UDR-5G-Max has integrated Wi-Fi");
+    }
+}