diff --git a/ComtradeWorkspaceWindow.Analysis.cs b/ComtradeWorkspaceWindow.Analysis.cs
index c63129054..b4140160f 100644
--- a/ComtradeWorkspaceWindow.Analysis.cs
+++ b/ComtradeWorkspaceWindow.Analysis.cs
@@ -16,6 +16,7 @@ private enum AnalysisMode
     }
 
     private AnalysisMode _analysisMode = AnalysisMode.Waveform;
+    private ComtradeDisturbanceCursor _phasorReferenceCursor = ComtradeDisturbanceCursor.Cursor1;
     private CancellationTokenSource? _analysisLoadCts;
     private bool _analysisEventsAttached;
 
@@ -41,23 +42,39 @@ private void AnalysisWindow_Closed(object? sender, EventArgs e)
     private void SignalList_AnalysisSelectionChanged(object sender, SelectionChangedEventArgs e)
     {
         UpdateAnalysisAvailability();
-        if (_activeSignal is { IsAnalog: false } && _analysisMode != AnalysisMode.Waveform)
+
+        // P1D.2D Phasor is a record-level Voltage + Current workstation and no longer depends on
+        // the selected signal row. Harmonics remains a selected-analog-channel workflow until its
+        // own parity slice lands.
+        if (_analysisMode == AnalysisMode.Harmonics && _activeSignal is not { IsAnalog: true })
         {
             SetAnalysisMode(AnalysisMode.Waveform);
             return;
         }
 
-        if (_analysisMode != AnalysisMode.Waveform)
+        if (_analysisMode == AnalysisMode.Harmonics)
             _ = Dispatcher.InvokeAsync(async () => await RefreshNativeAnalysisAsync().ConfigureAwait(true));
     }
 
     private void WaveformMode_Click(object sender, RoutedEventArgs e) => SetAnalysisMode(AnalysisMode.Waveform);
     private void PhasorMode_Click(object sender, RoutedEventArgs e) => SetAnalysisMode(AnalysisMode.Phasor);
     private void HarmonicsMode_Click(object sender, RoutedEventArgs e) => SetAnalysisMode(AnalysisMode.Harmonics);
+    private void PhasorCursor1_Click(object sender, RoutedEventArgs e) => SetPhasorReferenceCursor(ComtradeDisturbanceCursor.Cursor1);
+    private void PhasorCursor2_Click(object sender, RoutedEventArgs e) => SetPhasorReferenceCursor(ComtradeDisturbanceCursor.Cursor2);
+
+    private void SetPhasorReferenceCursor(ComtradeDisturbanceCursor cursor)
+    {
+        _phasorReferenceCursor = cursor;
+        ApplyPhasorCursorVisuals();
+        if (_analysisMode == AnalysisMode.Phasor)
+            _ = RefreshNativeAnalysisAsync();
+    }
 
     private void SetAnalysisMode(AnalysisMode mode)
     {
-        if (mode != AnalysisMode.Waveform && _activeSignal is not { IsAnalog: true })
+        if (mode == AnalysisMode.Phasor && _record.Info.AnalogCount == 0)
+            mode = AnalysisMode.Waveform;
+        if (mode == AnalysisMode.Harmonics && _activeSignal is not { IsAnalog: true })
             mode = AnalysisMode.Waveform;
 
         _analysisMode = mode;
@@ -65,11 +82,11 @@ private void SetAnalysisMode(AnalysisMode mode)
         WaveformView.Visibility = Visibility.Collapsed;
         PhasorView.Visibility = mode == AnalysisMode.Phasor ? Visibility.Visible : Visibility.Collapsed;
         HarmonicsView.Visibility = mode == AnalysisMode.Harmonics ? Visibility.Visible : Visibility.Collapsed;
-        ResetViewButton.Visibility = mode == AnalysisMode.Waveform ? Visibility.Visible : Visibility.Collapsed;
-        FullRecordButton.Visibility = mode == AnalysisMode.Waveform ? Visibility.Visible : Visibility.Collapsed;
+        TimeNavigationPanel.Visibility = mode == AnalysisMode.Waveform ? Visibility.Visible : Visibility.Collapsed;
+        PhasorReferencePanel.Visibility = mode == AnalysisMode.Phasor ? Visibility.Visible : Visibility.Collapsed;
         NavigationTextBlock.Text = mode switch
         {
-            AnalysisMode.Phasor => "C1 = phasor reference • native one-cycle DFT • select an analog signal family on the left",
+            AnalysisMode.Phasor => "Dual Voltage / Current diagrams • choose C1 or C2 • native one-cycle DFT • common phase reference",
             AnalysisMode.Harmonics => "C1 = harmonic reference • full-cycle native DFT • click a bar for details",
             _ => "Wheel scrolls tracks • Ctrl+wheel zooms time • drag plot pans • drag C1/C2 measures • right-click places C2"
         };
@@ -81,19 +98,21 @@ private void SetAnalysisMode(AnalysisMode mode)
 
     private void UpdateAnalysisAvailability()
     {
-        var analog = _activeSignal is { IsAnalog: true };
-        PhasorModeButton.IsEnabled = analog;
-        HarmonicsModeButton.IsEnabled = analog;
-        if (!analog)
-        {
-            PhasorModeButton.ToolTip = "Select an analog signal first. C1 on Time Signals becomes the phasor reference.";
-            HarmonicsModeButton.ToolTip = "Select an analog signal first. C1 on Time Signals becomes the harmonic reference.";
-        }
-        else
-        {
-            PhasorModeButton.ToolTip = "Show same-unit fundamental RMS phasors at C1 (or the visible Time Signals center when C1 is unset).";
-            HarmonicsModeButton.ToolTip = "Show native ArdIrec harmonic spectrum at C1 (or the visible Time Signals center when C1 is unset).";
-        }
+        var hasAnalogRecord = _record.Info.AnalogCount > 0;
+        var selectedAnalog = _activeSignal is { IsAnalog: true };
+        PhasorModeButton.IsEnabled = hasAnalogRecord;
+        HarmonicsModeButton.IsEnabled = selectedAnalog;
+
+        PhasorModeButton.ToolTip = hasAnalogRecord
+            ? "Show record-level Voltage and Current fundamental RMS phasors at global C1 or C2."
+            : "This COMTRADE record contains no analog channels.";
+        HarmonicsModeButton.ToolTip = selectedAnalog
+            ? "Show native ArdIrec harmonic spectrum at C1 (or the visible Time Signals center when C1 is unset)."
+            : "Select an analog signal first. C1 on Time Signals becomes the harmonic reference.";
+
+        PhasorCursor1Button.IsEnabled = DisturbanceView.Cursor1Milliseconds.HasValue;
+        PhasorCursor2Button.IsEnabled = DisturbanceView.Cursor2Milliseconds.HasValue;
+        ApplyPhasorCursorVisuals();
     }
 
     private void ApplyAnalysisModeVisuals()
@@ -101,6 +120,7 @@ private void ApplyAnalysisModeVisuals()
         ApplyModeButton(WaveformModeButton, _analysisMode == AnalysisMode.Waveform);
         ApplyModeButton(PhasorModeButton, _analysisMode == AnalysisMode.Phasor);
         ApplyModeButton(HarmonicsModeButton, _analysisMode == AnalysisMode.Harmonics);
+        ApplyPhasorCursorVisuals();
     }
 
     private static void ApplyModeButton(Button button, bool selected)
@@ -111,47 +131,82 @@ private static void ApplyModeButton(Button button, bool selected)
         button.BorderThickness = new Thickness(1);
     }
 
+    private void ApplyPhasorCursorVisuals()
+    {
+        ApplyCursorButton(
+            PhasorCursor1Button,
+            _phasorReferenceCursor == ComtradeDisturbanceCursor.Cursor1,
+            Color.FromRgb(221, 142, 32),
+            Color.FromRgb(255, 247, 232));
+        ApplyCursorButton(
+            PhasorCursor2Button,
+            _phasorReferenceCursor == ComtradeDisturbanceCursor.Cursor2,
+            Color.FromRgb(36, 172, 211),
+            Color.FromRgb(235, 249, 253));
+    }
+
+    private static void ApplyCursorButton(Button button, bool selected, Color accent, Color selectedBackground)
+    {
+        button.Foreground = new SolidColorBrush(selected ? accent : Color.FromRgb(94, 111, 132));
+        button.Background = new SolidColorBrush(selected ? selectedBackground : Colors.White);
+        button.BorderBrush = new SolidColorBrush(selected ? accent : Color.FromRgb(203, 216, 231));
+        button.BorderThickness = new Thickness(1);
+    }
+
     private async Task RefreshNativeAnalysisAsync()
     {
-        if (_analysisMode == AnalysisMode.Waveform || _activeSignal is not { IsAnalog: true } signal)
+        if (_analysisMode == AnalysisMode.Waveform)
+            return;
+        if (_analysisMode == AnalysisMode.Harmonics && _activeSignal is not { IsAnalog: true })
             return;
 
         _analysisLoadCts?.Cancel();
         _analysisLoadCts?.Dispose();
         _analysisLoadCts = new CancellationTokenSource();
         var token = _analysisLoadCts.Token;
-        var cursorReference = TryResolveDisturbanceCursorFrame(out var cursorFrame);
-        var referenceFrame = cursorReference ? cursorFrame : ResolveAnalysisReferenceFrame();
+        var preferredCursor = _analysisMode == AnalysisMode.Phasor
+            ? _phasorReferenceCursor
+            : ComtradeDisturbanceCursor.Cursor1;
+        var cursorReference = TryResolveAnalysisCursorFrame(preferredCursor, out var cursorFrame);
+        var referenceFrame = cursorReference ? cursorFrame : ResolveAnalysisReferenceFrame(preferredCursor);
         var timeMs = await TryReadReferenceTimeMillisecondsAsync(referenceFrame, token).ConfigureAwait(true);
         if (token.IsCancellationRequested) return;
         var triggerMs = ResolveTriggerMilliseconds();
         var relative = timeMs is { } absolute && triggerMs is { } trigger ? absolute - trigger : (double?)null;
-        AnalysisReferenceTextBlock.Text = timeMs is { } ms
-            ? $"Analysis reference: {(cursorReference ? "C1" : "visible center")} • frame {referenceFrame:N0} • " +
-              (relative is { } rel ? ComtradeDisturbanceTimelineMath.FormatRelativeTime(rel) : $"{ms:G7} ms")
-            : $"Analysis reference: {(cursorReference ? "C1" : "visible center")} • frame {referenceFrame:N0}";
+        var referenceName = cursorReference ? CursorName(preferredCursor) : "visible center";
+        var referenceTimeText = relative is { } relativeMs
+            ? ComtradeDisturbanceTimelineMath.FormatRelativeTime(relativeMs)
+            : timeMs is { } absoluteMs
+                ? $"{absoluteMs:G7} ms"
+                : "time unavailable";
+        AnalysisReferenceTextBlock.Text = $"Analysis reference: {referenceName} • frame {referenceFrame:N0} • {referenceTimeText}";
 
         try
         {
             if (_analysisMode == AnalysisMode.Phasor)
             {
-                PhasorView.ShowMessage("Phasor", "Calculating native one-cycle phasors…");
-                var result = await LoadPhasorGroupAsync(signal, referenceFrame, token).ConfigureAwait(true);
+                PhasorView.ShowMessage("Phasor", "Calculating native Voltage and Current one-cycle phasors…");
+                var result = await LoadPhasorWorkspaceAsync(referenceFrame, token).ConfigureAwait(true);
                 if (token.IsCancellationRequested || _analysisMode != AnalysisMode.Phasor) return;
-                if (result.Count == 0)
+                if (result.VoltageVectors.Count == 0 && result.CurrentVectors.Count == 0)
                 {
-                    PhasorView.ShowMessage("Phasor", "The selected reference does not contain a complete analyzable cycle.");
+                    PhasorView.ShowMessage("Phasor", "The selected reference does not contain a complete analyzable Voltage or Current cycle.");
+                    StatusTextBlock.Text = $"Native ArdIrec phasor analysis • {referenceName} • no valid Voltage/Current vectors.";
                     return;
                 }
 
-                var selectedMetadata = _record.AnalogChannels[checked((int)signal.Index)];
-                var subtitle = BuildAnalysisSubtitle(selectedMetadata, referenceFrame, result.Count,
-                    "fundamental RMS • same-unit channels");
-                PhasorView.ShowPhasors("Phasor diagram", subtitle, result);
-                StatusTextBlock.Text = $"Native ArdIrec phasor analysis • {(cursorReference ? "C1" : "visible center")} • frame {referenceFrame:N0} • {result.Count} vector(s)";
+                var detail = $"{referenceTimeText} • frame {referenceFrame:N0} • full-cycle DFT • RMS magnitude • common phase reference";
+                PhasorView.ShowPhasors(
+                    referenceName.ToUpperInvariant(),
+                    detail,
+                    result.VoltageVectors,
+                    result.CurrentVectors);
+                StatusTextBlock.Text = $"Native ArdIrec phasor workstation • {referenceName} • frame {referenceFrame:N0} • " +
+                                       $"{result.VoltageVectors.Count} voltage + {result.CurrentVectors.Count} current vector(s)";
                 return;
             }
 
+            var signal = _activeSignal!;
             HarmonicsView.ShowMessage("Harmonics", "Calculating native harmonic spectrum…");
             var spectrum = await LoadHarmonicsAsync(signal, referenceFrame, token).ConfigureAwait(true);
             if (token.IsCancellationRequested || _analysisMode != AnalysisMode.Harmonics) return;
@@ -177,7 +232,7 @@ private async Task RefreshNativeAnalysisAsync()
             var harmonicSubtitle = BuildAnalysisSubtitle(metadata, referenceFrame, spectrum.Bins.Count,
                 $"orders H1…H{spectrum.Bins[^1].Order}");
             HarmonicsView.ShowSpectrum("Harmonic spectrum", harmonicSubtitle, display);
-            StatusTextBlock.Text = $"Native ArdIrec harmonics • {(cursorReference ? "C1" : "visible center")} • THD {spectrum.ThdPercent:G5}% • " +
+            StatusTextBlock.Text = $"Native ArdIrec harmonics • {referenceName} • THD {spectrum.ThdPercent:G5}% • " +
                                    (spectrum.DominantOrder > 1
                                        ? $"dominant H{spectrum.DominantOrder} {spectrum.DominantPercent:G4}%"
                                        : "no meaningful distortion harmonic");
@@ -198,9 +253,18 @@ private async Task RefreshNativeAnalysisAsync()
         }
     }
 
-    private ulong ResolveAnalysisReferenceFrame()
+    private bool TryResolveAnalysisCursorFrame(ComtradeDisturbanceCursor cursor, out ulong frame)
+    {
+        frame = 0;
+        var milliseconds = cursor == ComtradeDisturbanceCursor.Cursor1
+            ? DisturbanceView.Cursor1Milliseconds
+            : DisturbanceView.Cursor2Milliseconds;
+        return milliseconds is { } value && TryResolveDisturbanceFrameAtMilliseconds(value, out frame);
+    }
+
+    private ulong ResolveAnalysisReferenceFrame(ComtradeDisturbanceCursor preferredCursor)
     {
-        if (TryResolveDisturbanceCursorFrame(out var cursorFrame))
+        if (TryResolveAnalysisCursorFrame(preferredCursor, out var cursorFrame))
             return cursorFrame;
         if (TryResolveDisturbanceViewportCenterFrame(out var centerFrame))
             return centerFrame;
@@ -225,8 +289,7 @@ private ulong ResolveAnalysisReferenceFrame()
         }
     }
 
-    private async Task<IReadOnlyList<ComtradePhasorVector>> LoadPhasorGroupAsync(
-        ComtradeSignalItem signal,
+    private async Task<ComtradePhasorWorkspaceResult> LoadPhasorWorkspaceAsync(
         ulong referenceFrame,
         CancellationToken token)
     {
@@ -236,33 +299,43 @@ private async Task<IReadOnlyList<ComtradePhasorVector>> LoadPhasorGroupAsync(
             return await Task.Run(() =>
             {
                 token.ThrowIfCancellationRequested();
-                var selected = _record.AnalogChannels[checked((int)signal.Index)];
-                var sameUnits = _record.AnalogChannels
-                    .Select((channel, index) => (channel, index))
-                    .Where(item => string.Equals(item.channel.Units?.Trim(), selected.Units?.Trim(), StringComparison.OrdinalIgnoreCase))
-                    .ToArray();
-                var sameCircuit = sameUnits
-                    .Where(item => !string.IsNullOrWhiteSpace(selected.Circuit) &&
-                                   string.Equals(item.channel.Circuit?.Trim(), selected.Circuit?.Trim(), StringComparison.OrdinalIgnoreCase))
-                    .ToArray();
-                var candidates = sameCircuit.Length >= 2 ? sameCircuit : sameUnits;
-                if (candidates.Length == 0)
-                    candidates = new[] { (selected, checked((int)signal.Index)) };
-
-                var vectors = new List<ComtradePhasorVector>();
-                foreach (var item in candidates.Take(8))
+                var descriptors = new List<ComtradePhasorChannelDescriptor>(_record.AnalogChannels.Count);
+                for (var index = 0; index < _record.AnalogChannels.Count; index++)
                 {
                     token.ThrowIfCancellationRequested();
-                    var phasor = _record.ReadPhasor(checked((uint)item.index), referenceFrame);
-                    if (!phasor.Valid) continue;
-                    vectors.Add(new ComtradePhasorVector(
-                        item.channel.Id,
-                        NormalizePhase(item.channel.Phase, item.channel.Id),
-                        item.channel.Units,
-                        phasor.MagnitudeRms,
-                        phasor.AngleDegrees));
+                    var channel = _record.AnalogChannels[index];
+                    var hasSemantics = _record.TryReadAnalogSemantics(checked((uint)index), out var semantics) && semantics is not null;
+                    var fallbackPhase = NormalizePhase(channel.Phase, channel.Id);
+                    var role = hasSemantics
+                        ? semantics!.Role
+                        : ResolveAnalogSection(channel.Units, null) switch
+                        {
+                            "Voltage" => ComtradePhasorWorkspaceMath.RoleVoltage,
+                            "Current" => ComtradePhasorWorkspaceMath.RoleCurrent,
+                            _ => 0
+                        };
+                    var phaseRole = hasSemantics
+                        ? semantics!.PhaseRole
+                        : ComtradePhasorWorkspaceMath.PhaseRoleFromCanonicalName(fallbackPhase);
+                    descriptors.Add(new ComtradePhasorChannelDescriptor(
+                        checked((uint)index),
+                        role,
+                        phaseRole,
+                        channel.Id,
+                        ComtradePhasorWorkspaceMath.CanonicalPhaseName(phaseRole, fallbackPhase),
+                        channel.Circuit,
+                        channel.Units));
                 }
-                return (IReadOnlyList<ComtradePhasorVector>)vectors;
+
+                var voltageChannels = ComtradePhasorWorkspaceMath.SelectRoleSet(
+                    descriptors,
+                    ComtradePhasorWorkspaceMath.RoleVoltage);
+                var currentChannels = ComtradePhasorWorkspaceMath.SelectRoleSet(
+                    descriptors,
+                    ComtradePhasorWorkspaceMath.RoleCurrent);
+                var voltageVectors = ReadPhasorVectors(voltageChannels, referenceFrame, token);
+                var currentVectors = ReadPhasorVectors(currentChannels, referenceFrame, token);
+                return new ComtradePhasorWorkspaceResult(voltageVectors, currentVectors);
             }, token).ConfigureAwait(false);
         }
         finally
@@ -271,6 +344,27 @@ private async Task<IReadOnlyList<ComtradePhasorVector>> LoadPhasorGroupAsync(
         }
     }
 
+    private IReadOnlyList<ComtradePhasorVector> ReadPhasorVectors(
+        IReadOnlyList<ComtradePhasorChannelDescriptor> channels,
+        ulong referenceFrame,
+        CancellationToken token)
+    {
+        var vectors = new List<ComtradePhasorVector>(channels.Count);
+        foreach (var channel in channels)
+        {
+            token.ThrowIfCancellationRequested();
+            var phasor = _record.ReadPhasor(channel.Index, referenceFrame);
+            if (!phasor.Valid) continue;
+            vectors.Add(new ComtradePhasorVector(
+                channel.Label,
+                ComtradePhasorWorkspaceMath.CanonicalPhaseName(channel.PhaseRole, channel.Phase),
+                channel.Units,
+                phasor.MagnitudeRms,
+                phasor.AngleDegrees));
+        }
+        return vectors;
+    }
+
     private async Task<ComtradeHarmonicSpectrum> LoadHarmonicsAsync(
         ComtradeSignalItem signal,
         ulong referenceFrame,
@@ -299,6 +393,9 @@ private static string BuildAnalysisSubtitle(
         return $"{context} • reference frame {referenceFrame:N0} • {itemCount} {suffix}";
     }
 
+    private static string CursorName(ComtradeDisturbanceCursor cursor)
+        => cursor == ComtradeDisturbanceCursor.Cursor1 ? "C1" : "C2";
+
     private static string NormalizePhase(string phase, string id)
     {
         var direct = (phase ?? string.Empty).Trim().ToUpperInvariant();
@@ -314,4 +411,8 @@ private static string NormalizePhase(string phase, string id)
         if (name.Contains("3I0") || name.Contains("3V0") || name.Contains("3U0") || name.Contains("RES") || name.Contains("NEUTRAL")) return "E";
         return "Other";
     }
+
+    private sealed record ComtradePhasorWorkspaceResult(
+        IReadOnlyList<ComtradePhasorVector> VoltageVectors,
+        IReadOnlyList<ComtradePhasorVector> CurrentVectors);
 }
diff --git a/ComtradeWorkspaceWindow.xaml b/ComtradeWorkspaceWindow.xaml
index 97a0ce940..467690abc 100644
--- a/ComtradeWorkspaceWindow.xaml
+++ b/ComtradeWorkspaceWindow.xaml
@@ -177,16 +177,29 @@
                             <TextBlock x:Name="NavigationTextBlock"
                                        Text="Wheel scrolls signals • Ctrl+wheel zooms time • drag plot pans • drag C1/C2 moves • right-click places C2"
                                        FontSize="10" Foreground="#64778F" VerticalAlignment="Center" TextTrimming="CharacterEllipsis"/>
-                            <StackPanel Grid.Column="1" Orientation="Horizontal" Margin="12,0,0,0">
-                                <Button x:Name="ResetViewButton" Content="Trigger view" Height="25" MinWidth="82"
-                                        Padding="10,0" FontSize="10" FontWeight="SemiBold" Foreground="#365D88" Background="White"
-                                        BorderBrush="#CBD8E7" BorderThickness="1" Cursor="Hand"
-                                        ToolTip="Return to the trigger-focused engineering window (about eight nominal cycles)." Click="DisturbanceReset_Click"/>
-                                <Button x:Name="FullRecordButton" Content="Full record" Height="25" MinWidth="78" Margin="5,0,0,0"
-                                        Padding="10,0" FontSize="10" FontWeight="SemiBold" Foreground="#586F89" Background="White"
-                                        BorderBrush="#CBD8E7" BorderThickness="1" Cursor="Hand"
-                                        ToolTip="Show the complete COMTRADE time range." Click="DisturbanceFullRecord_Click"/>
-                            </StackPanel>
+                            <Grid Grid.Column="1" Margin="12,0,0,0">
+                                <StackPanel x:Name="TimeNavigationPanel" Orientation="Horizontal">
+                                    <Button x:Name="ResetViewButton" Content="Trigger view" Height="25" MinWidth="82"
+                                            Padding="10,0" FontSize="10" FontWeight="SemiBold" Foreground="#365D88" Background="White"
+                                            BorderBrush="#CBD8E7" BorderThickness="1" Cursor="Hand"
+                                            ToolTip="Return to the trigger-focused engineering window (about eight nominal cycles)." Click="DisturbanceReset_Click"/>
+                                    <Button x:Name="FullRecordButton" Content="Full record" Height="25" MinWidth="78" Margin="5,0,0,0"
+                                            Padding="10,0" FontSize="10" FontWeight="SemiBold" Foreground="#586F89" Background="White"
+                                            BorderBrush="#CBD8E7" BorderThickness="1" Cursor="Hand"
+                                            ToolTip="Show the complete COMTRADE time range." Click="DisturbanceFullRecord_Click"/>
+                                </StackPanel>
+                                <StackPanel x:Name="PhasorReferencePanel" Orientation="Horizontal" Visibility="Collapsed" VerticalAlignment="Center">
+                                    <TextBlock Text="Reference" Margin="0,0,7,0" FontSize="9.5" Foreground="#77889C" VerticalAlignment="Center"/>
+                                    <Button x:Name="PhasorCursor1Button" Content="C1" Height="25" MinWidth="42" Padding="9,0"
+                                            FontSize="10" FontWeight="SemiBold" Cursor="Hand"
+                                            ToolTip="Use global Time Signals cursor C1 for both Voltage and Current phasor diagrams."
+                                            Click="PhasorCursor1_Click"/>
+                                    <Button x:Name="PhasorCursor2Button" Content="C2" Height="25" MinWidth="42" Margin="5,0,0,0" Padding="9,0"
+                                            FontSize="10" FontWeight="SemiBold" Cursor="Hand"
+                                            ToolTip="Use global Time Signals cursor C2 for both Voltage and Current phasor diagrams."
+                                            Click="PhasorCursor2_Click"/>
+                                </StackPanel>
+                            </Grid>
                         </Grid>
                     </Border>
 
diff --git a/Controls/ComtradePhasorView.cs b/Controls/ComtradePhasorView.cs
index 91cd2a4da..228debeb6 100644
--- a/Controls/ComtradePhasorView.cs
+++ b/Controls/ComtradePhasorView.cs
@@ -13,23 +13,33 @@ internal sealed record ComtradePhasorVector(
 
 public sealed class ComtradePhasorView : FrameworkElement
 {
-    private IReadOnlyList<ComtradePhasorVector> _vectors = Array.Empty<ComtradePhasorVector>();
-    private string _title = "Phasor";
-    private string _subtitle = "Select an analog signal";
+    private IReadOnlyList<ComtradePhasorVector> _voltageVectors = Array.Empty<ComtradePhasorVector>();
+    private IReadOnlyList<ComtradePhasorVector> _currentVectors = Array.Empty<ComtradePhasorVector>();
+    private string _referenceLabel = "C1";
+    private string _referenceDetail = "Select a valid analysis reference";
+    private string _message = string.Empty;
 
-    internal void ShowPhasors(string title, string subtitle, IReadOnlyList<ComtradePhasorVector> vectors)
+    internal void ShowPhasors(
+        string referenceLabel,
+        string referenceDetail,
+        IReadOnlyList<ComtradePhasorVector> voltageVectors,
+        IReadOnlyList<ComtradePhasorVector> currentVectors)
     {
-        _title = title;
-        _subtitle = subtitle;
-        _vectors = vectors.Where(v => double.IsFinite(v.MagnitudeRms) && double.IsFinite(v.AngleDegrees)).ToArray();
+        _referenceLabel = string.IsNullOrWhiteSpace(referenceLabel) ? "Reference" : referenceLabel;
+        _referenceDetail = referenceDetail ?? string.Empty;
+        _voltageVectors = Filter(voltageVectors);
+        _currentVectors = Filter(currentVectors);
+        _message = string.Empty;
         InvalidateVisual();
     }
 
     internal void ShowMessage(string title, string message)
     {
-        _title = title;
-        _subtitle = message;
-        _vectors = Array.Empty<ComtradePhasorVector>();
+        _referenceLabel = string.IsNullOrWhiteSpace(title) ? "Phasor" : title;
+        _referenceDetail = message ?? string.Empty;
+        _voltageVectors = Array.Empty<ComtradePhasorVector>();
+        _currentVectors = Array.Empty<ComtradePhasorVector>();
+        _message = message ?? string.Empty;
         InvalidateVisual();
     }
 
@@ -38,45 +48,117 @@ protected override void OnRender(DrawingContext dc)
         base.OnRender(dc);
         var bounds = new Rect(0, 0, Math.Max(0, ActualWidth), Math.Max(0, ActualHeight));
         dc.DrawRectangle(Brushes.White, null, bounds);
-        if (bounds.Width < 260 || bounds.Height < 220) return;
+        if (bounds.Width < 320 || bounds.Height < 260) return;
 
         var dpi = VisualTreeHelper.GetDpi(this).PixelsPerDip;
         var body = new Typeface("Segoe UI");
         var semibold = new Typeface("Segoe UI Semibold");
-        DrawText(dc, _title, 15, semibold, Color.FromRgb(31, 50, 74), new Point(18, 14), dpi);
-        DrawText(dc, _subtitle, 10.8, body, Color.FromRgb(103, 120, 141), new Point(18, 39), dpi);
+        var header = new Rect(0, 0, bounds.Width, 58);
+        dc.DrawRectangle(new SolidColorBrush(Color.FromRgb(248, 250, 253)), null, header);
+        dc.DrawLine(FrozenPen(Color.FromRgb(225, 232, 241), 1), new Point(0, header.Bottom), new Point(bounds.Right, header.Bottom));
 
-        if (_vectors.Count == 0)
+        DrawText(dc, $"Fundamental phasors at {_referenceLabel}", 14.5, semibold,
+            Color.FromRgb(37, 56, 79), new Point(16, 10), dpi);
+        DrawText(dc, _referenceDetail, 10.2, body,
+            Color.FromRgb(102, 119, 139), new Point(16, 34), dpi, Math.Max(100, bounds.Width - 32));
+
+        if (_voltageVectors.Count == 0 && _currentVectors.Count == 0)
         {
-            DrawText(dc, "No valid phasor at the analysis reference.", 12, body,
-                Color.FromRgb(126, 139, 156), new Point(24, 82), dpi);
+            DrawText(dc,
+                string.IsNullOrWhiteSpace(_message) ? "No valid voltage or current phasors at this reference." : _message,
+                12, body, Color.FromRgb(126, 139, 156), new Point(24, 90), dpi,
+                Math.Max(100, bounds.Width - 48));
             return;
         }
 
-        var legendWidth = Math.Clamp(bounds.Width * 0.29, 210, 300);
-        var plotArea = new Rect(18, 65, Math.Max(120, bounds.Width - legendWidth - 48), Math.Max(120, bounds.Height - 88));
-        var radius = Math.Max(45, Math.Min(plotArea.Width, plotArea.Height) * 0.43);
-        var center = new Point(plotArea.Left + plotArea.Width * 0.5, plotArea.Top + plotArea.Height * 0.5);
+        const double outer = 10;
+        const double gap = 8;
+        var content = new Rect(outer, header.Bottom + outer, bounds.Width - outer * 2, bounds.Height - header.Bottom - outer * 2);
+        if (bounds.Width >= 820)
+        {
+            var panelWidth = Math.Max(240, (content.Width - gap) / 2.0);
+            DrawPanel(dc, new Rect(content.Left, content.Top, panelWidth, content.Height),
+                "VOLTAGE PHASORS", _voltageVectors, dpi, body, semibold);
+            DrawPanel(dc, new Rect(content.Left + panelWidth + gap, content.Top, content.Width - panelWidth - gap, content.Height),
+                "CURRENT PHASORS", _currentVectors, dpi, body, semibold);
+        }
+        else
+        {
+            var panelHeight = Math.Max(190, (content.Height - gap) / 2.0);
+            DrawPanel(dc, new Rect(content.Left, content.Top, content.Width, panelHeight),
+                "VOLTAGE PHASORS", _voltageVectors, dpi, body, semibold);
+            DrawPanel(dc, new Rect(content.Left, content.Top + panelHeight + gap, content.Width, content.Height - panelHeight - gap),
+                "CURRENT PHASORS", _currentVectors, dpi, body, semibold);
+        }
+    }
+
+    private static IReadOnlyList<ComtradePhasorVector> Filter(IReadOnlyList<ComtradePhasorVector>? vectors)
+        => (vectors ?? Array.Empty<ComtradePhasorVector>())
+            .Where(vector => double.IsFinite(vector.MagnitudeRms) && vector.MagnitudeRms >= 0 && double.IsFinite(vector.AngleDegrees))
+            .ToArray();
+
+    private static void DrawPanel(
+        DrawingContext dc,
+        Rect panel,
+        string title,
+        IReadOnlyList<ComtradePhasorVector> vectors,
+        double dpi,
+        Typeface body,
+        Typeface semibold)
+    {
+        if (panel.Width <= 1 || panel.Height <= 1) return;
+        var background = new SolidColorBrush(Color.FromRgb(252, 253, 255)); background.Freeze();
+        dc.DrawRoundedRectangle(background, FrozenPen(Color.FromRgb(205, 216, 229), 1), panel, 5, 5);
+        DrawText(dc, title, 10.2, semibold, Color.FromRgb(58, 71, 84), new Point(panel.Left + 11, panel.Top + 8), dpi);
+
+        if (vectors.Count == 0)
+        {
+            DrawText(dc, "No mapped channels with a valid one-cycle phasor.", 10.5, body,
+                Color.FromRgb(126, 139, 156), new Point(panel.Left + 14, panel.Top + 43), dpi,
+                Math.Max(80, panel.Width - 28));
+            return;
+        }
+
+        var distinctUnits = vectors.Select(vector => vector.Units?.Trim() ?? string.Empty)
+            .Where(unit => unit.Length > 0)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+        var unitSummary = distinctUnits.Length == 1 ? distinctUnits[0] : distinctUnits.Length > 1 ? "mixed units" : string.Empty;
+        DrawText(dc, $"{vectors.Count} vector{(vectors.Count == 1 ? string.Empty : "s")}" +
+                     (string.IsNullOrWhiteSpace(unitSummary) ? string.Empty : $" • {unitSummary}"),
+            8.8, body, Color.FromRgb(119, 132, 149), new Point(panel.Left + 11, panel.Top + 26), dpi,
+            Math.Max(60, panel.Width - 22));
+
+        var legendRows = Math.Min(4, vectors.Count);
+        var legendHeight = Math.Clamp(legendRows * 25.0 + 12.0, 42.0, 112.0);
+        var plotTop = panel.Top + 47;
+        var plotBottom = panel.Bottom - legendHeight - 4;
+        var plot = new Rect(panel.Left + 9, plotTop, Math.Max(60, panel.Width - 18), Math.Max(70, plotBottom - plotTop));
+        var radius = Math.Max(30, Math.Min(plot.Width, plot.Height) * 0.39);
+        var center = new Point(plot.Left + plot.Width * 0.5, plot.Top + plot.Height * 0.5);
         DrawPolarGrid(dc, center, radius, dpi, body);
 
-        var maxMagnitude = _vectors.Max(v => Math.Abs(v.MagnitudeRms));
+        var maxMagnitude = vectors.Max(vector => Math.Abs(vector.MagnitudeRms));
         if (!double.IsFinite(maxMagnitude) || maxMagnitude <= 1e-12) maxMagnitude = 1.0;
-        foreach (var vector in _vectors)
+        foreach (var vector in vectors)
             DrawVector(dc, center, radius, maxMagnitude, vector, dpi, semibold);
 
-        DrawLegend(dc, new Point(bounds.Right - legendWidth - 14, 72), legendWidth, dpi, body, semibold);
+        var maxUnit = distinctUnits.Length == 1 ? $" {distinctUnits[0]}" : string.Empty;
+        DrawText(dc, $"100% = {maxMagnitude:G6}{maxUnit}", 8.1, body, Color.FromRgb(135, 147, 162),
+            new Point(plot.Left + 5, plot.Bottom - 15), dpi);
+        DrawCompactLegend(dc,
+            new Rect(panel.Left + 10, panel.Bottom - legendHeight + 2, panel.Width - 20, legendHeight - 7),
+            vectors, dpi, body, semibold);
     }
 
     private static void DrawPolarGrid(DrawingContext dc, Point center, double radius, double dpi, Typeface body)
     {
-        var minorPen = FrozenPen(Color.FromRgb(229, 234, 241), 1.0);
-        var axisPen = FrozenPen(Color.FromRgb(183, 195, 209), 1.05);
+        var minorPen = FrozenPen(Color.FromRgb(233, 237, 242), 0.9);
+        var axisPen = FrozenPen(Color.FromRgb(181, 190, 200), 1.0);
         for (var ring = 1; ring <= 4; ring++)
         {
             var r = radius * ring / 4.0;
             dc.DrawEllipse(null, ring == 4 ? axisPen : minorPen, center, r, r);
-            DrawText(dc, $"{ring * 25}%", 8.8, body, Color.FromRgb(143, 154, 169),
-                new Point(center.X + 4, center.Y - r + 2), dpi);
         }
 
         for (var degrees = 0; degrees < 360; degrees += 30)
@@ -86,50 +168,84 @@ private static void DrawPolarGrid(DrawingContext dc, Point center, double radius
             dc.DrawLine(degrees % 90 == 0 ? axisPen : minorPen, center, end);
         }
 
-        DrawText(dc, "0°", 9.2, body, Color.FromRgb(108, 122, 140), new Point(center.X + radius + 5, center.Y - 7), dpi);
-        DrawText(dc, "+90°", 9.2, body, Color.FromRgb(108, 122, 140), new Point(center.X - 14, center.Y - radius - 17), dpi);
-        DrawText(dc, "±180°", 9.2, body, Color.FromRgb(108, 122, 140), new Point(center.X - radius - 42, center.Y - 7), dpi);
-        DrawText(dc, "−90°", 9.2, body, Color.FromRgb(108, 122, 140), new Point(center.X - 15, center.Y + radius + 5), dpi);
-        dc.DrawEllipse(new SolidColorBrush(Color.FromRgb(83, 101, 122)), null, center, 2.5, 2.5);
+        DrawText(dc, "0°", 7.8, body, Color.FromRgb(119, 132, 149), new Point(center.X + radius + 3, center.Y - 6), dpi);
+        DrawText(dc, "+90°", 7.8, body, Color.FromRgb(119, 132, 149), new Point(center.X - 13, center.Y - radius - 14), dpi);
+        DrawText(dc, "±180°", 7.8, body, Color.FromRgb(119, 132, 149), new Point(center.X - radius - 34, center.Y - 6), dpi);
+        DrawText(dc, "−90°", 7.8, body, Color.FromRgb(119, 132, 149), new Point(center.X - 13, center.Y + radius + 3), dpi);
+        dc.DrawEllipse(new SolidColorBrush(Color.FromRgb(80, 95, 112)), null, center, 2.2, 2.2);
     }
 
-    private static void DrawVector(DrawingContext dc, Point center, double radius, double maxMagnitude,
-        ComtradePhasorVector vector, double dpi, Typeface typeface)
+    private static void DrawVector(
+        DrawingContext dc,
+        Point center,
+        double radius,
+        double maxMagnitude,
+        ComtradePhasorVector vector,
+        double dpi,
+        Typeface typeface)
     {
         var color = PhaseColor(vector.Phase);
         var fraction = Math.Clamp(Math.Abs(vector.MagnitudeRms) / maxMagnitude, 0.0, 1.0);
         var length = radius * fraction;
         var radians = vector.AngleDegrees * Math.PI / 180.0;
         var end = new Point(center.X + Math.Cos(radians) * length, center.Y - Math.Sin(radians) * length);
-        var pen = FrozenPen(color, 2.0);
+        var pen = FrozenPen(color, vector.Phase is "E" or "N" ? 1.5 : 2.0);
         dc.DrawLine(pen, center, end);
 
         if (length > 8)
         {
-            var head = 8.0;
-            var leftAngle = radians + Math.PI * 0.88;
-            var rightAngle = radians - Math.PI * 0.88;
-            dc.DrawLine(pen, end, new Point(end.X + Math.Cos(leftAngle) * head, end.Y - Math.Sin(leftAngle) * head));
-            dc.DrawLine(pen, end, new Point(end.X + Math.Cos(rightAngle) * head, end.Y - Math.Sin(rightAngle) * head));
+            const double head = 7.5;
+            var leftAngle = radians + Math.PI * 0.86;
+            var rightAngle = radians - Math.PI * 0.86;
+            var geometry = new StreamGeometry();
+            using (var context = geometry.Open())
+            {
+                context.BeginFigure(end, true, true);
+                context.LineTo(new Point(end.X + Math.Cos(leftAngle) * head, end.Y - Math.Sin(leftAngle) * head), true, false);
+                context.LineTo(new Point(end.X + Math.Cos(rightAngle) * head, end.Y - Math.Sin(rightAngle) * head), true, false);
+            }
+            geometry.Freeze();
+            var brush = new SolidColorBrush(color); brush.Freeze();
+            dc.DrawGeometry(brush, null, geometry);
         }
 
-        var labelPoint = new Point(end.X + (Math.Cos(radians) >= 0 ? 6 : -30), end.Y - 15);
-        DrawText(dc, vector.Label, 9.2, typeface, color, labelPoint, dpi);
+        if (length > radius * 0.22)
+        {
+            var labelPoint = new Point(end.X + (Math.Cos(radians) >= 0 ? 5 : -28), end.Y - 13);
+            DrawText(dc, vector.Phase, 8.7, typeface, color, labelPoint, dpi, 32);
+        }
     }
 
-    private void DrawLegend(DrawingContext dc, Point origin, double width, double dpi, Typeface body, Typeface semibold)
+    private static void DrawCompactLegend(
+        DrawingContext dc,
+        Rect area,
+        IReadOnlyList<ComtradePhasorVector> vectors,
+        double dpi,
+        Typeface body,
+        Typeface semibold)
     {
-        DrawText(dc, "RMS phasors", 11.5, semibold, Color.FromRgb(49, 70, 94), origin, dpi);
-        var y = origin.Y + 25;
-        foreach (var vector in _vectors.Take(10))
+        var columns = area.Width >= 420 ? 2 : 1;
+        var rows = (int)Math.Ceiling(vectors.Count / (double)columns);
+        rows = Math.Max(1, rows);
+        var columnWidth = area.Width / columns;
+        var rowHeight = Math.Max(21, area.Height / rows);
+        for (var index = 0; index < vectors.Count; index++)
         {
+            var column = index / rows;
+            var row = index % rows;
+            if (column >= columns) break;
+            var vector = vectors[index];
+            var x = area.Left + column * columnWidth;
+            var y = area.Top + row * rowHeight;
             var color = PhaseColor(vector.Phase);
-            dc.DrawEllipse(new SolidColorBrush(color), null, new Point(origin.X + 4, y + 6), 3.5, 3.5);
-            DrawText(dc, vector.Label, 10.5, semibold, Color.FromRgb(48, 65, 86), new Point(origin.X + 15, y - 1), dpi);
+            dc.DrawLine(FrozenPen(color, 2.0), new Point(x, y + 8), new Point(x + 12, y + 8));
+            DrawText(dc, vector.Label, 8.8, semibold, Color.FromRgb(65, 78, 94),
+                new Point(x + 17, y), dpi, Math.Max(40, columnWidth * 0.42));
             var unit = string.IsNullOrWhiteSpace(vector.Units) ? string.Empty : " " + vector.Units;
-            DrawText(dc, $"{vector.MagnitudeRms:G6}{unit}  ∠ {vector.AngleDegrees:+0.##;-0.##;0}°",
-                9.8, body, Color.FromRgb(103, 119, 139), new Point(origin.X + 15, y + 14), dpi);
-            y += 43;
+            DrawText(dc, $"{vector.MagnitudeRms:G6}{unit}  ∠{vector.AngleDegrees:+0.##;-0.##;0}°",
+                8.3, body, Color.FromRgb(103, 117, 135),
+                new Point(x + Math.Max(86, columnWidth * 0.43), y), dpi,
+                Math.Max(40, columnWidth - Math.Max(86, columnWidth * 0.43) - 4));
         }
     }
 
@@ -153,10 +269,23 @@ private static Pen FrozenPen(Color color, double thickness)
         return pen;
     }
 
-    private static void DrawText(DrawingContext dc, string text, double size, Typeface typeface, Color color, Point point, double dpi)
+    private static void DrawText(
+        DrawingContext dc,
+        string text,
+        double size,
+        Typeface typeface,
+        Color color,
+        Point point,
+        double dpi,
+        double maxWidth = double.PositiveInfinity)
     {
         var brush = new SolidColorBrush(color); brush.Freeze();
-        dc.DrawText(new FormattedText(text, CultureInfo.CurrentCulture, FlowDirection.LeftToRight,
-            typeface, size, brush, dpi), point);
+        var formatted = new FormattedText(text ?? string.Empty, CultureInfo.CurrentCulture, FlowDirection.LeftToRight,
+            typeface, size, brush, dpi)
+        {
+            MaxTextWidth = double.IsFinite(maxWidth) ? Math.Max(1, maxWidth) : 10000,
+            Trimming = TextTrimming.CharacterEllipsis
+        };
+        dc.DrawText(formatted, point);
     }
 }
diff --git a/Services/ComtradePhasorWorkspaceMath.cs b/Services/ComtradePhasorWorkspaceMath.cs
new file mode 100644
index 000000000..e9a0a0639
--- /dev/null
+++ b/Services/ComtradePhasorWorkspaceMath.cs
@@ -0,0 +1,109 @@
+namespace ArIED61850Tester.Services;
+
+internal sealed record ComtradePhasorChannelDescriptor(
+    uint Index,
+    int Role,
+    int PhaseRole,
+    string Label,
+    string Phase,
+    string Circuit,
+    string Units);
+
+internal static class ComtradePhasorWorkspaceMath
+{
+    internal const int RoleVoltage = 1;
+    internal const int RoleCurrent = 2;
+    internal const int PhaseL1 = 1;
+    internal const int PhaseL2 = 2;
+    internal const int PhaseL3 = 3;
+    internal const int PhaseNeutral = 4;
+
+    internal static IReadOnlyList<ComtradePhasorChannelDescriptor> SelectRoleSet(
+        IEnumerable<ComtradePhasorChannelDescriptor> channels,
+        int role)
+    {
+        ArgumentNullException.ThrowIfNull(channels);
+        var candidates = channels
+            .Where(channel => channel.Role == role && IsDisplayPhase(channel.PhaseRole))
+            .OrderBy(channel => channel.Index)
+            .ToArray();
+        if (candidates.Length == 0)
+            return Array.Empty<ComtradePhasorChannelDescriptor>();
+
+        // A polar diagram has one radial scale, therefore do not silently compare unlike
+        // engineering units. Prefer the most complete same-circuit + same-unit phase set.
+        var coherentGroups = candidates
+            .GroupBy(channel => (Circuit: Normalize(channel.Circuit), Units: Normalize(channel.Units)))
+            .Select(group => new
+            {
+                Items = group.ToArray(),
+                PhaseCount = group.Select(item => item.PhaseRole).Distinct().Count(),
+                FirstIndex = group.Min(item => item.Index)
+            })
+            .OrderByDescending(group => group.PhaseCount)
+            .ThenBy(group => group.FirstIndex)
+            .ToArray();
+
+        var chosen = coherentGroups[0].Items;
+        if (coherentGroups[0].PhaseCount < 2)
+        {
+            // Some recorders leave circuit blank/inconsistent per phase. In that case retain the
+            // dimension-safe unit boundary and choose the unit family with the best phase coverage.
+            chosen = candidates
+                .GroupBy(channel => Normalize(channel.Units))
+                .Select(group => new
+                {
+                    Items = group.ToArray(),
+                    PhaseCount = group.Select(item => item.PhaseRole).Distinct().Count(),
+                    FirstIndex = group.Min(item => item.Index)
+                })
+                .OrderByDescending(group => group.PhaseCount)
+                .ThenBy(group => group.FirstIndex)
+                .First()
+                .Items;
+        }
+
+        return chosen
+            .GroupBy(channel => channel.PhaseRole)
+            .Select(group => group.OrderBy(channel => channel.Index).First())
+            .OrderBy(channel => PhaseRank(channel.PhaseRole))
+            .ThenBy(channel => channel.Index)
+            .ToArray();
+    }
+
+    internal static int PhaseRoleFromCanonicalName(string? phase)
+        => (phase ?? string.Empty).Trim().ToUpperInvariant() switch
+        {
+            "L1" or "A" => PhaseL1,
+            "L2" or "B" => PhaseL2,
+            "L3" or "C" => PhaseL3,
+            "N" or "E" => PhaseNeutral,
+            _ => 0
+        };
+
+    internal static string CanonicalPhaseName(int phaseRole, string? fallback = null)
+        => phaseRole switch
+        {
+            PhaseL1 => "L1",
+            PhaseL2 => "L2",
+            PhaseL3 => "L3",
+            PhaseNeutral => "E",
+            _ => string.IsNullOrWhiteSpace(fallback) ? "Other" : fallback.Trim()
+        };
+
+    private static bool IsDisplayPhase(int phaseRole)
+        => phaseRole is PhaseL1 or PhaseL2 or PhaseL3 or PhaseNeutral;
+
+    private static int PhaseRank(int phaseRole)
+        => phaseRole switch
+        {
+            PhaseL1 => 0,
+            PhaseL2 => 1,
+            PhaseL3 => 2,
+            PhaseNeutral => 3,
+            _ => 9
+        };
+
+    private static string Normalize(string? value)
+        => (value ?? string.Empty).Trim().ToUpperInvariant();
+}
diff --git a/docs/P1D2D_PHASOR_WORKSTATION_PARITY.md b/docs/P1D2D_PHASOR_WORKSTATION_PARITY.md
new file mode 100644
index 000000000..800ad1437
--- /dev/null
+++ b/docs/P1D2D_PHASOR_WORKSTATION_PARITY.md
@@ -0,0 +1,44 @@
+# P1D.2D — Phasor workstation parity
+
+P1D.2D ports ArdIrec's record-level Phasor workflow into the native ARSAS WPF COMTRADE workspace. Native ArdIrec remains the calculation authority; WPF only selects the investigation reference and renders the returned vectors.
+
+## Operator contract
+
+- Phasor is a record-level view. It does not require the currently highlighted signal row to be analog.
+- Voltage and Current diagrams are visible at the same time.
+- The two diagrams use independent radial scales. Volts and amps are never compared on one numeric scale.
+- Both diagrams use one global investigation reference selected from C1 or C2.
+- C1/C2 positions remain owned by Time Signals; switching the Phasor reference does not move either cursor.
+- The reference strip reports the exact native source frame and trigger-relative time used for the DFT.
+- Moving between Time Signals and Phasor does not reset C1/C2.
+
+## Channel selection
+
+ArdIrec P1D.2A analog role and phase semantics are authoritative when the capability is present.
+
+For each electrical role, ARSAS selects one coherent phase family:
+
+1. prefer the same circuit and same engineering unit with the largest distinct L1/L2/L3/E coverage;
+2. if circuit metadata is sparse or phase-specific, fall back to the same engineering-unit family with the largest phase coverage;
+3. keep the first source channel for duplicate phase identities;
+4. order displayed vectors L1, L2, L3, E.
+
+This prevents one normalized polar plot from silently mixing unlike units or unrelated bay circuits.
+
+## Calculation boundary
+
+- Fundamental RMS magnitude and angle come only from `ardirec_record_get_phasor`.
+- ARSAS does not implement a second DFT, RMS, phase-angle or sample-window algorithm.
+- P1D.2A Primary/Secondary representation capability is not surfaced here. The global representation/measurement UI remains the P1D.2B responsibility.
+- Harmonics remains the existing selected-channel/C1 workflow until its own parity slice.
+- Locus / distance and Engineering Table are outside P1D.2D.
+
+## Acceptance
+
+- Two simultaneous Voltage/Current panels on a record containing both roles.
+- Phasor remains available after a digital row is selected.
+- C1 and C2 can each become the active Phasor reference without changing cursor position.
+- The exact source frame follows P1D.2C timestamp/source-frame identity on large and multi-rate records.
+- Native role/phase semantics drive phase-family selection.
+- Same-unit and coherent-circuit selection is deterministic and regression tested.
+- Existing Time Signals, Harmonics, native bridge, installer and compatibility-viewer gates stay green.
diff --git a/tests/ARSAS.Tests/ComtradePhasorWorkspaceMathTests.cs b/tests/ARSAS.Tests/ComtradePhasorWorkspaceMathTests.cs
new file mode 100644
index 000000000..529da7532
--- /dev/null
+++ b/tests/ARSAS.Tests/ComtradePhasorWorkspaceMathTests.cs
@@ -0,0 +1,101 @@
+using ArIED61850Tester.Services;
+
+namespace ARSAS.Tests;
+
+public sealed class ComtradePhasorWorkspaceMathTests
+{
+    [Fact]
+    public void SelectRoleSet_OrdersElectricalPhasesAndKeepsVoltageCurrentIndependent()
+    {
+        var channels = new[]
+        {
+            D(8, 2, 3, "IC", "C", "Bay 1", "A"),
+            D(2, 1, 2, "VB", "B", "Bay 1", "V"),
+            D(7, 2, 1, "IA", "A", "Bay 1", "A"),
+            D(1, 1, 1, "VA", "A", "Bay 1", "V"),
+            D(3, 1, 3, "VC", "C", "Bay 1", "V"),
+            D(9, 2, 2, "IB", "B", "Bay 1", "A")
+        };
+
+        var voltage = ComtradePhasorWorkspaceMath.SelectRoleSet(channels, ComtradePhasorWorkspaceMath.RoleVoltage);
+        var current = ComtradePhasorWorkspaceMath.SelectRoleSet(channels, ComtradePhasorWorkspaceMath.RoleCurrent);
+
+        Assert.Equal(new uint[] { 1, 2, 3 }, voltage.Select(item => item.Index));
+        Assert.Equal(new uint[] { 7, 9, 8 }, current.Select(item => item.Index));
+    }
+
+    [Fact]
+    public void SelectRoleSet_PrefersMostCompleteSameCircuitAndUnitFamily()
+    {
+        var channels = new[]
+        {
+            D(0, 1, 1, "VA-Bay2", "A", "Bay 2", "V"),
+            D(1, 1, 1, "VA", "A", "Bay 1", "V"),
+            D(2, 1, 2, "VB", "B", "Bay 1", "V"),
+            D(3, 1, 3, "VC", "C", "Bay 1", "V"),
+            D(4, 1, 2, "VB-kV", "B", "Bay 1", "kV")
+        };
+
+        var selected = ComtradePhasorWorkspaceMath.SelectRoleSet(channels, ComtradePhasorWorkspaceMath.RoleVoltage);
+
+        Assert.Equal(new uint[] { 1, 2, 3 }, selected.Select(item => item.Index));
+        Assert.All(selected, item => Assert.Equal("V", item.Units));
+        Assert.All(selected, item => Assert.Equal("Bay 1", item.Circuit));
+    }
+
+    [Fact]
+    public void SelectRoleSet_FallsBackToSameUnitWhenCircuitMetadataIsSparse()
+    {
+        var channels = new[]
+        {
+            D(0, 2, 1, "IA", "A", "CT-A", "A"),
+            D(1, 2, 2, "IB", "B", "CT-B", "A"),
+            D(2, 2, 3, "IC", "C", "CT-C", "A"),
+            D(3, 2, 1, "IA-kA", "A", "Other", "kA")
+        };
+
+        var selected = ComtradePhasorWorkspaceMath.SelectRoleSet(channels, ComtradePhasorWorkspaceMath.RoleCurrent);
+
+        Assert.Equal(new uint[] { 0, 1, 2 }, selected.Select(item => item.Index));
+        Assert.All(selected, item => Assert.Equal("A", item.Units));
+    }
+
+    [Fact]
+    public void SelectRoleSet_KeepsOneChannelPerPhaseAndIgnoresOtherPhase()
+    {
+        var channels = new[]
+        {
+            D(0, 1, 1, "VA-1", "A", "Bay", "V"),
+            D(1, 1, 1, "VA-duplicate", "A", "Bay", "V"),
+            D(2, 1, 4, "VE", "E", "Bay", "V"),
+            D(3, 1, 0, "Aux", "", "Bay", "V")
+        };
+
+        var selected = ComtradePhasorWorkspaceMath.SelectRoleSet(channels, ComtradePhasorWorkspaceMath.RoleVoltage);
+
+        Assert.Equal(new uint[] { 0, 2 }, selected.Select(item => item.Index));
+    }
+
+    [Theory]
+    [InlineData("A", 1)]
+    [InlineData("L1", 1)]
+    [InlineData("B", 2)]
+    [InlineData("L2", 2)]
+    [InlineData("C", 3)]
+    [InlineData("L3", 3)]
+    [InlineData("N", 4)]
+    [InlineData("E", 4)]
+    [InlineData("Other", 0)]
+    public void PhaseRoleFromCanonicalName_MapsExpectedNames(string phase, int expected)
+        => Assert.Equal(expected, ComtradePhasorWorkspaceMath.PhaseRoleFromCanonicalName(phase));
+
+    private static ComtradePhasorChannelDescriptor D(
+        uint index,
+        int role,
+        int phaseRole,
+        string label,
+        string phase,
+        string circuit,
+        string units)
+        => new(index, role, phaseRole, label, phase, circuit, units);
+}