diff --git a/docs/sv-measurement-context.md b/docs/sv-measurement-context.md
new file mode 100644
index 0000000..8c90ca6
--- /dev/null
+++ b/docs/sv-measurement-context.md
@@ -0,0 +1,68 @@
+# SV measurement context
+
+ArSubsv separates three different measurement concepts:
+
+1. the raw protocol count,
+2. the profile-scaled wire engineering value,
+3. a primary or secondary-equivalent display value produced from explicit CT/VT context.
+
+The Subscriber never derives a transformer ratio from vendor identity, signal amplitude, APPID, MAC address, or `svID` naming.
+
+## User workflow
+
+1. Select a discovered SV stream.
+2. Open **CT/VT** from the responsive toolbar.
+3. Declare whether the scaled value on the wire is interpreted as `PrimaryEngineering` or `SecondaryEquivalent`.
+4. Choose the preferred display domain.
+5. Enter current and/or voltage primary and secondary nominal values.
+6. Record the evidence source and reference.
+7. Apply the context.
+
+Waveform, decoded engineering values, RMS, and phasors use the preferred domain only when the relevant ratio is valid. A missing current ratio does not prevent a verified voltage ratio from being used, and vice versa. Channels without sufficient context stay in their wire engineering domain.
+
+## JSON evidence document
+
+Use **Ctx Export** to save configured contexts. Use **Ctx Import** to restore them or apply them before the corresponding stream is discovered.
+
+```json
+{
+  "schemaVersion": 1,
+  "exportedAt": "2026-07-22T08:30:00Z",
+  "streams": [
+    {
+      "streamKey": "logical-stream-key",
+      "svId": "MU01",
+      "wireDomain": "PrimaryEngineering",
+      "displayDomain": "SecondaryEquivalent",
+      "currentRatio": {
+        "primaryNominal": 1000,
+        "secondaryNominal": 1,
+        "unit": "A",
+        "source": "DeviceConfiguration",
+        "reference": "SMU current input configuration"
+      },
+      "voltageRatio": {
+        "primaryNominal": 20000,
+        "secondaryNominal": 100,
+        "unit": "V",
+        "source": "DeviceConfiguration",
+        "reference": "SMU voltage input configuration"
+      },
+      "notes": "Matched to the sanitized SCL and known-injection PCAP"
+    }
+  ]
+}
+```
+
+## Evidence rules
+
+- `Manual` means the values were entered by an engineer and should be checked against the test record.
+- `Scl` means the ratio was obtained from an explicit, reviewable SCL source.
+- `DeviceConfiguration` means the ratio was read from a device configuration or setting export.
+- `DeviceValidated` means the context has been checked against real-device capture and known-injection evidence.
+- Empty ratio fields are preferable to guessed values.
+- Context conversion changes presentation; it does not alter the captured bytes or raw protocol values.
+
+## Validation boundary
+
+The context workflow makes primary/secondary interpretation explicit and repeatable. It does not turn a Windows PC into a calibrated test set, and it does not replace device-specific injection validation.
diff --git a/src/ARSVIN.Engine/SampledValues/Measurements/SvMeasurementContextDocument.cs b/src/ARSVIN.Engine/SampledValues/Measurements/SvMeasurementContextDocument.cs
new file mode 100644
index 0000000..098e4fc
--- /dev/null
+++ b/src/ARSVIN.Engine/SampledValues/Measurements/SvMeasurementContextDocument.cs
@@ -0,0 +1,160 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace AR.Iec61850.SampledValues.Measurements;
+
+/// <summary>
+/// User-supplied measurement-domain context for one logical SV stream.
+/// The stream key is the evidence identity used by the Subscriber, not a vendor name.
+/// </summary>
+public sealed record SvStreamMeasurementContext
+{
+    public string StreamKey { get; init; } = string.Empty;
+    public string SvId { get; init; } = string.Empty;
+    public SvMeasurementValueDomain WireDomain { get; init; } = SvMeasurementValueDomain.PrimaryEngineering;
+    public SvMeasurementValueDomain DisplayDomain { get; init; } = SvMeasurementValueDomain.PrimaryEngineering;
+    public SvMeasurementRatio? CurrentRatio { get; init; }
+    public SvMeasurementRatio? VoltageRatio { get; init; }
+    public string Notes { get; init; } = string.Empty;
+    public DateTimeOffset UpdatedAt { get; init; } = DateTimeOffset.UtcNow;
+
+    public SvMeasurementRatio? ResolveRatio(string kindOrChannel)
+    {
+        var text = kindOrChannel?.Trim() ?? string.Empty;
+        if (text.Contains("voltage", StringComparison.OrdinalIgnoreCase) ||
+            text.StartsWith("V", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("TVTR", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("VolSv", StringComparison.OrdinalIgnoreCase))
+            return VoltageRatio;
+
+        if (text.Contains("current", StringComparison.OrdinalIgnoreCase) ||
+            text.StartsWith("I", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("TCTR", StringComparison.OrdinalIgnoreCase) ||
+            text.Contains("AmpSv", StringComparison.OrdinalIgnoreCase))
+            return CurrentRatio;
+
+        return null;
+    }
+
+    public string Summary
+    {
+        get
+        {
+            var current = CurrentRatio?.IsValid == true
+                ? $"I {CurrentRatio.PrimaryNominal:0.###}/{CurrentRatio.SecondaryNominal:0.###} {CurrentRatio.Unit}"
+                : "I ratio unset";
+            var voltage = VoltageRatio?.IsValid == true
+                ? $"V {VoltageRatio.PrimaryNominal:0.###}/{VoltageRatio.SecondaryNominal:0.###} {VoltageRatio.Unit}"
+                : "V ratio unset";
+            return $"wire {WireDomain} → display {DisplayDomain} · {current} · {voltage}";
+        }
+    }
+
+    public IReadOnlyList<string> Validate()
+    {
+        var errors = new List<string>();
+        if (string.IsNullOrWhiteSpace(StreamKey))
+            errors.Add("StreamKey is required.");
+        if (WireDomain is not (SvMeasurementValueDomain.PrimaryEngineering or SvMeasurementValueDomain.SecondaryEquivalent))
+            errors.Add("WireDomain must be PrimaryEngineering or SecondaryEquivalent.");
+        if (DisplayDomain is not (SvMeasurementValueDomain.PrimaryEngineering or SvMeasurementValueDomain.SecondaryEquivalent))
+            errors.Add("DisplayDomain must be PrimaryEngineering or SecondaryEquivalent.");
+
+        ValidateRatio(CurrentRatio, "current", "A", errors);
+        ValidateRatio(VoltageRatio, "voltage", "V", errors);
+        return errors;
+    }
+
+    private static void ValidateRatio(
+        SvMeasurementRatio? ratio,
+        string label,
+        string expectedUnit,
+        ICollection<string> errors)
+    {
+        if (ratio is null)
+            return;
+        if (!ratio.IsValid)
+            errors.Add($"The {label} ratio requires positive finite primary and secondary nominal values.");
+        if (!string.Equals(ratio.Unit, expectedUnit, StringComparison.OrdinalIgnoreCase))
+            errors.Add($"The {label} ratio unit must be {expectedUnit}.");
+        if (ratio.Source == SvRatioSource.Unknown)
+            errors.Add($"The {label} ratio source must be explicit.");
+    }
+}
+
+public sealed record SvMeasurementContextDocument
+{
+    public const int CurrentSchemaVersion = 1;
+
+    public int SchemaVersion { get; init; } = CurrentSchemaVersion;
+    public DateTimeOffset ExportedAt { get; init; } = DateTimeOffset.UtcNow;
+    public IReadOnlyList<SvStreamMeasurementContext> Streams { get; init; }
+        = Array.Empty<SvStreamMeasurementContext>();
+
+    public IReadOnlyList<string> Validate()
+    {
+        var errors = new List<string>();
+        if (SchemaVersion != CurrentSchemaVersion)
+            errors.Add($"Unsupported measurement-context schema version {SchemaVersion}; expected {CurrentSchemaVersion}.");
+
+        var duplicateKeys = Streams
+            .Where(item => !string.IsNullOrWhiteSpace(item.StreamKey))
+            .GroupBy(item => item.StreamKey, StringComparer.Ordinal)
+            .Where(group => group.Count() > 1)
+            .Select(group => group.Key)
+            .ToArray();
+        errors.AddRange(duplicateKeys.Select(key => $"Duplicate measurement context for stream key '{key}'."));
+
+        foreach (var stream in Streams)
+        {
+            var label = string.IsNullOrWhiteSpace(stream.SvId) ? stream.StreamKey : stream.SvId;
+            errors.AddRange(stream.Validate().Select(error => $"{label}: {error}"));
+        }
+        return errors;
+    }
+}
+
+public static class SvMeasurementContextSerializer
+{
+    private static readonly JsonSerializerOptions Options = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true,
+        WriteIndented = true,
+        Converters = { new JsonStringEnumConverter() }
+    };
+
+    public static string ToJson(SvMeasurementContextDocument document)
+    {
+        ArgumentNullException.ThrowIfNull(document);
+        EnsureValid(document);
+        return JsonSerializer.Serialize(document, Options);
+    }
+
+    public static SvMeasurementContextDocument FromJson(string json)
+    {
+        if (string.IsNullOrWhiteSpace(json))
+            throw new InvalidDataException("Measurement-context JSON is empty.");
+
+        SvMeasurementContextDocument document;
+        try
+        {
+            document = JsonSerializer.Deserialize<SvMeasurementContextDocument>(json, Options)
+                ?? throw new InvalidDataException("Measurement-context JSON did not contain a document.");
+        }
+        catch (JsonException ex)
+        {
+            throw new InvalidDataException($"Measurement-context JSON is invalid: {ex.Message}", ex);
+        }
+
+        EnsureValid(document);
+        return document;
+    }
+
+    private static void EnsureValid(SvMeasurementContextDocument document)
+    {
+        var errors = document.Validate();
+        if (errors.Count > 0)
+            throw new InvalidDataException("Measurement-context validation failed: " + string.Join(" ", errors));
+    }
+}
diff --git a/src/ARSVIN.Subscriber/MainWindow.xaml.cs b/src/ARSVIN.Subscriber/MainWindow.xaml.cs
index 43bd8ab..0a42d46 100644
--- a/src/ARSVIN.Subscriber/MainWindow.xaml.cs
+++ b/src/ARSVIN.Subscriber/MainWindow.xaml.cs
@@ -1,6 +1,10 @@
+using System.Collections.Specialized;
 using System.Text.Json;
 using System.Windows;
+using System.Windows.Controls;
 using System.Windows.Data;
+using System.Windows.Media;
+using AR.Iec61850.SampledValues.Measurements;
 using AR.Iec61850.SampledValues.Reporting;
 using ARSVIN.Subscriber.Controls;
 using ARSVIN.Subscriber.ViewModels;
@@ -11,13 +15,17 @@ namespace ARSVIN.Subscriber;
 public partial class MainWindow : Window
 {
     private readonly SvSubscriberViewModel _viewModel;
+    private readonly Dictionary<string, SvStreamMeasurementContext> _measurementContexts =
+        new(StringComparer.Ordinal);
 
     public MainWindow()
     {
         InitializeComponent();
         _viewModel = new SvSubscriberViewModel();
         DataContext = _viewModel;
+        _viewModel.Streams.CollectionChanged += Streams_CollectionChanged;
         AttachLivePlotControls();
+        Loaded += (_, _) => AttachMeasurementContextToolbar();
     }
 
     private void AttachLivePlotControls()
@@ -37,6 +45,200 @@ private void AttachLivePlotControls()
         PhasorHost.Child = phasor;
     }
 
+    private void AttachMeasurementContextToolbar()
+    {
+        var toolbar = FindVisualChildren<WrapPanel>(this)
+            .FirstOrDefault(panel => panel.Children.OfType<Button>()
+                .Any(button => string.Equals(button.Content?.ToString(), "Import SCL", StringComparison.Ordinal)));
+        if (toolbar is null || toolbar.Children.OfType<Button>()
+                .Any(button => string.Equals(button.Tag?.ToString(), "measurement-context", StringComparison.Ordinal)))
+            return;
+
+        toolbar.Children.Add(CreateToolbarButton("CT/VT", "measurement-context", MeasurementContext_Click,
+            "Edit primary/secondary CT and VT context for the selected stream."));
+        toolbar.Children.Add(CreateToolbarButton("Ctx Import", "measurement-context-import", ImportMeasurementContext_Click,
+            "Import a versioned ARSVIN measurement-context JSON document."));
+        toolbar.Children.Add(CreateToolbarButton("Ctx Export", "measurement-context-export", ExportMeasurementContext_Click,
+            "Export configured stream measurement contexts as JSON evidence."));
+    }
+
+    private Button CreateToolbarButton(
+        string content,
+        string tag,
+        RoutedEventHandler click,
+        string toolTip)
+    {
+        var button = new Button
+        {
+            Content = content,
+            Tag = tag,
+            ToolTip = toolTip,
+            Margin = new Thickness(0, 0, 6, 0)
+        };
+        button.SetResourceReference(StyleProperty, "ToolbarButton");
+        button.Click += click;
+        return button;
+    }
+
+    private static IEnumerable<T> FindVisualChildren<T>(DependencyObject root)
+        where T : DependencyObject
+    {
+        for (var index = 0; index < VisualTreeHelper.GetChildrenCount(root); index++)
+        {
+            var child = VisualTreeHelper.GetChild(root, index);
+            if (child is T typed)
+                yield return typed;
+            foreach (var descendant in FindVisualChildren<T>(child))
+                yield return descendant;
+        }
+    }
+
+    private void Streams_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        if (e.NewItems is null)
+            return;
+
+        foreach (var row in e.NewItems.OfType<SvStreamViewModel>())
+        {
+            if (_measurementContexts.TryGetValue(row.Key, out var context))
+                row.SetMeasurementContext(context);
+        }
+    }
+
+    private void MeasurementContext_Click(object sender, RoutedEventArgs e)
+    {
+        var selected = _viewModel.SelectedStream;
+        if (selected is null)
+        {
+            MessageBox.Show(
+                this,
+                "Select an SV stream before editing CT/VT measurement context.",
+                "SV Measurement Context",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+            return;
+        }
+
+        _measurementContexts.TryGetValue(selected.Key, out var existing);
+        var dialog = new MeasurementContextWindow(selected.Key, selected.SvId, existing)
+        {
+            Owner = this
+        };
+        if (dialog.ShowDialog() != true)
+            return;
+
+        if (dialog.RemoveRequested)
+        {
+            _measurementContexts.Remove(selected.Key);
+            selected.SetMeasurementContext(null);
+            return;
+        }
+
+        if (dialog.ResultContext is not { } context)
+            return;
+
+        _measurementContexts[selected.Key] = context;
+        selected.SetMeasurementContext(context);
+    }
+
+    private async void ImportMeasurementContext_Click(object sender, RoutedEventArgs e)
+    {
+        var dialog = new OpenFileDialog
+        {
+            Title = "Import ARSVIN measurement-context JSON",
+            Filter = "ARSVIN measurement context (*.json)|*.json|All files (*.*)|*.*",
+            Multiselect = false
+        };
+        if (dialog.ShowDialog(this) != true)
+            return;
+
+        try
+        {
+            var json = await File.ReadAllTextAsync(dialog.FileName).ConfigureAwait(true);
+            var document = SvMeasurementContextSerializer.FromJson(json);
+            foreach (var context in document.Streams)
+                _measurementContexts[context.StreamKey] = context;
+
+            foreach (var row in _viewModel.Streams)
+            {
+                if (_measurementContexts.TryGetValue(row.Key, out var context))
+                    row.SetMeasurementContext(context);
+            }
+
+            MessageBox.Show(
+                this,
+                $"Imported {document.Streams.Count} measurement context(s). Existing matching stream keys were updated.",
+                "SV Measurement Context",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException)
+        {
+            MessageBox.Show(
+                this,
+                $"Measurement-context import failed: {ex.Message}",
+                "SV Measurement Context",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+    }
+
+    private async void ExportMeasurementContext_Click(object sender, RoutedEventArgs e)
+    {
+        if (_measurementContexts.Count == 0)
+        {
+            MessageBox.Show(
+                this,
+                "No measurement context has been configured yet.",
+                "SV Measurement Context",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+            return;
+        }
+
+        var dialog = new SaveFileDialog
+        {
+            Title = "Export ARSVIN measurement-context JSON",
+            Filter = "ARSVIN measurement context (*.json)|*.json|All files (*.*)|*.*",
+            DefaultExt = ".json",
+            AddExtension = true,
+            FileName = $"arsvin-measurement-context-{DateTime.Now:yyyyMMdd-HHmmss}.json"
+        };
+        if (dialog.ShowDialog(this) != true)
+            return;
+
+        try
+        {
+            var document = new SvMeasurementContextDocument
+            {
+                ExportedAt = DateTimeOffset.UtcNow,
+                Streams = _measurementContexts.Values
+                    .OrderBy(item => item.SvId, StringComparer.Ordinal)
+                    .ThenBy(item => item.StreamKey, StringComparer.Ordinal)
+                    .ToArray()
+            };
+            await File.WriteAllTextAsync(
+                dialog.FileName,
+                SvMeasurementContextSerializer.ToJson(document)).ConfigureAwait(true);
+
+            MessageBox.Show(
+                this,
+                $"Exported {_measurementContexts.Count} measurement context(s) to {Path.GetFileName(dialog.FileName)}.",
+                "SV Measurement Context",
+                MessageBoxButton.OK,
+                MessageBoxImage.Information);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or InvalidDataException)
+        {
+            MessageBox.Show(
+                this,
+                $"Measurement-context export failed: {ex.Message}",
+                "SV Measurement Context",
+                MessageBoxButton.OK,
+                MessageBoxImage.Error);
+        }
+    }
+
     private async void CompareEvidence_Click(object sender, RoutedEventArgs e)
     {
         var baselineDialog = new OpenFileDialog
@@ -113,6 +315,7 @@ ArgumentException or InvalidDataException or
 
     protected override void OnClosed(EventArgs e)
     {
+        _viewModel.Streams.CollectionChanged -= Streams_CollectionChanged;
         _viewModel.Dispose();
         base.OnClosed(e);
     }
diff --git a/src/ARSVIN.Subscriber/MeasurementContextWindow.xaml b/src/ARSVIN.Subscriber/MeasurementContextWindow.xaml
new file mode 100644
index 0000000..4e7365c
--- /dev/null
+++ b/src/ARSVIN.Subscriber/MeasurementContextWindow.xaml
@@ -0,0 +1,140 @@
+<Window x:Class="ARSVIN.Subscriber.MeasurementContextWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        Title="SV Measurement Context"
+        Width="620"
+        Height="650"
+        MinWidth="560"
+        MinHeight="600"
+        Background="{StaticResource ShellBg}"
+        WindowStartupLocation="CenterOwner"
+        ResizeMode="CanResizeWithGrip"
+        SnapsToDevicePixels="True"
+        UseLayoutRounding="True">
+    <Grid Margin="14">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <Border Grid.Row="0" Style="{StaticResource PanelShell}" Padding="14" Margin="0,0,0,10">
+            <StackPanel>
+                <TextBlock Text="Primary / secondary measurement context" FontSize="17" FontWeight="SemiBold" />
+                <TextBlock x:Name="StreamText" Margin="0,5,0,0" Foreground="{StaticResource Muted}" TextWrapping="Wrap" />
+                <TextBlock Margin="0,6,0,0"
+                           Foreground="{StaticResource Dim}"
+                           FontSize="11"
+                           TextWrapping="Wrap"
+                           Text="Ratios are explicit engineering evidence. Device or vendor identity is never used to invent a ratio." />
+            </StackPanel>
+        </Border>
+
+        <ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto">
+            <StackPanel>
+                <Border Style="{StaticResource PanelShell}" Padding="14" Margin="0,0,0,10">
+                    <Grid>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="18" />
+                            <ColumnDefinition Width="*" />
+                        </Grid.ColumnDefinitions>
+                        <StackPanel Grid.Column="0">
+                            <TextBlock Text="Wire engineering domain" FontWeight="SemiBold" />
+                            <ComboBox x:Name="WireDomainBox" Margin="0,6,0,0" />
+                            <TextBlock Margin="0,4,0,0" FontSize="10.5" Foreground="{StaticResource Dim}" TextWrapping="Wrap"
+                                       Text="How the scaled SV value is interpreted before CT/VT conversion." />
+                        </StackPanel>
+                        <StackPanel Grid.Column="2">
+                            <TextBlock Text="Preferred display domain" FontWeight="SemiBold" />
+                            <ComboBox x:Name="DisplayDomainBox" Margin="0,6,0,0" />
+                            <TextBlock Margin="0,4,0,0" FontSize="10.5" Foreground="{StaticResource Dim}" TextWrapping="Wrap"
+                                       Text="Waveform, decoded values, RMS and phasors use this domain when a valid ratio exists." />
+                        </StackPanel>
+                    </Grid>
+                </Border>
+
+                <GroupBox Header="Current transformer / sensor context" Margin="0,0,0,10">
+                    <Grid Margin="10">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="12" />
+                            <ColumnDefinition Width="*" />
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition Height="Auto" />
+                        </Grid.RowDefinitions>
+                        <StackPanel Grid.Row="0" Grid.Column="0">
+                            <TextBlock Text="Primary nominal (A)" />
+                            <TextBox x:Name="CurrentPrimaryText" Margin="0,5,0,0" />
+                        </StackPanel>
+                        <StackPanel Grid.Row="0" Grid.Column="2">
+                            <TextBlock Text="Secondary nominal (A)" />
+                            <TextBox x:Name="CurrentSecondaryText" Margin="0,5,0,0" />
+                        </StackPanel>
+                        <StackPanel Grid.Row="1" Grid.Column="0" Margin="0,10,0,0">
+                            <TextBlock Text="Evidence source" />
+                            <ComboBox x:Name="CurrentSourceBox" Margin="0,5,0,0" />
+                        </StackPanel>
+                        <StackPanel Grid.Row="1" Grid.Column="2" Margin="0,10,0,0">
+                            <TextBlock Text="Reference" />
+                            <TextBox x:Name="CurrentReferenceText" Margin="0,5,0,0" ToolTip="For example: SMU615 current input configuration, SCL extension, or test record." />
+                        </StackPanel>
+                        <TextBlock Grid.Row="2" Grid.ColumnSpan="3" Margin="0,9,0,0" FontSize="10.5" Foreground="{StaticResource Dim}" TextWrapping="Wrap"
+                                   Text="Leave both nominal fields empty when current conversion is not established." />
+                    </Grid>
+                </GroupBox>
+
+                <GroupBox Header="Voltage transformer / sensor context" Margin="0,0,0,10">
+                    <Grid Margin="10">
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="12" />
+                            <ColumnDefinition Width="*" />
+                        </Grid.ColumnDefinitions>
+                        <Grid.RowDefinitions>
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition Height="Auto" />
+                            <RowDefinition Height="Auto" />
+                        </Grid.RowDefinitions>
+                        <StackPanel Grid.Row="0" Grid.Column="0">
+                            <TextBlock Text="Primary nominal (V)" />
+                            <TextBox x:Name="VoltagePrimaryText" Margin="0,5,0,0" />
+                        </StackPanel>
+                        <StackPanel Grid.Row="0" Grid.Column="2">
+                            <TextBlock Text="Secondary nominal (V)" />
+                            <TextBox x:Name="VoltageSecondaryText" Margin="0,5,0,0" />
+                        </StackPanel>
+                        <StackPanel Grid.Row="1" Grid.Column="0" Margin="0,10,0,0">
+                            <TextBlock Text="Evidence source" />
+                            <ComboBox x:Name="VoltageSourceBox" Margin="0,5,0,0" />
+                        </StackPanel>
+                        <StackPanel Grid.Row="1" Grid.Column="2" Margin="0,10,0,0">
+                            <TextBlock Text="Reference" />
+                            <TextBox x:Name="VoltageReferenceText" Margin="0,5,0,0" ToolTip="For example: SMU615 voltage input configuration, SCL extension, or test record." />
+                        </StackPanel>
+                        <TextBlock Grid.Row="2" Grid.ColumnSpan="3" Margin="0,9,0,0" FontSize="10.5" Foreground="{StaticResource Dim}" TextWrapping="Wrap"
+                                   Text="Leave both nominal fields empty when voltage conversion is not established." />
+                    </Grid>
+                </GroupBox>
+
+                <Border Style="{StaticResource PanelShell}" Padding="12">
+                    <StackPanel>
+                        <TextBlock Text="Engineering notes" FontWeight="SemiBold" />
+                        <TextBox x:Name="NotesText" Margin="0,6,0,0" MinHeight="62" AcceptsReturn="True" TextWrapping="Wrap" VerticalScrollBarVisibility="Auto" />
+                    </StackPanel>
+                </Border>
+            </StackPanel>
+        </ScrollViewer>
+
+        <DockPanel Grid.Row="2" Margin="0,12,0,0" LastChildFill="False">
+            <Button x:Name="RemoveButton" DockPanel.Dock="Left" Content="Remove context" Click="Remove_Click" MinWidth="110" />
+            <StackPanel DockPanel.Dock="Right" Orientation="Horizontal">
+                <Button Content="Cancel" Click="Cancel_Click" MinWidth="82" Margin="0,0,8,0" />
+                <Button Content="Apply" Click="Apply_Click" MinWidth="92" IsDefault="True" />
+            </StackPanel>
+        </DockPanel>
+    </Grid>
+</Window>
diff --git a/src/ARSVIN.Subscriber/MeasurementContextWindow.xaml.cs b/src/ARSVIN.Subscriber/MeasurementContextWindow.xaml.cs
new file mode 100644
index 0000000..b0b1750
--- /dev/null
+++ b/src/ARSVIN.Subscriber/MeasurementContextWindow.xaml.cs
@@ -0,0 +1,150 @@
+using System.Globalization;
+using System.Windows;
+using AR.Iec61850.SampledValues.Measurements;
+
+namespace ARSVIN.Subscriber;
+
+public partial class MeasurementContextWindow : Window
+{
+    private readonly string _streamKey;
+    private readonly string _svId;
+
+    public MeasurementContextWindow(
+        string streamKey,
+        string svId,
+        SvStreamMeasurementContext? existing)
+    {
+        InitializeComponent();
+        _streamKey = streamKey;
+        _svId = svId;
+
+        var domains = new[]
+        {
+            SvMeasurementValueDomain.PrimaryEngineering,
+            SvMeasurementValueDomain.SecondaryEquivalent
+        };
+        WireDomainBox.ItemsSource = domains;
+        DisplayDomainBox.ItemsSource = domains;
+
+        var ratioSources = Enum.GetValues<SvRatioSource>()
+            .Where(value => value != SvRatioSource.Unknown)
+            .ToArray();
+        CurrentSourceBox.ItemsSource = ratioSources;
+        VoltageSourceBox.ItemsSource = ratioSources;
+
+        StreamText.Text = $"{svId}\n{streamKey}";
+        WireDomainBox.SelectedItem = existing?.WireDomain ?? SvMeasurementValueDomain.PrimaryEngineering;
+        DisplayDomainBox.SelectedItem = existing?.DisplayDomain ?? SvMeasurementValueDomain.PrimaryEngineering;
+        CurrentSourceBox.SelectedItem = existing?.CurrentRatio?.Source ?? SvRatioSource.Manual;
+        VoltageSourceBox.SelectedItem = existing?.VoltageRatio?.Source ?? SvRatioSource.Manual;
+        CurrentPrimaryText.Text = Format(existing?.CurrentRatio?.PrimaryNominal);
+        CurrentSecondaryText.Text = Format(existing?.CurrentRatio?.SecondaryNominal);
+        CurrentReferenceText.Text = existing?.CurrentRatio?.Reference ?? string.Empty;
+        VoltagePrimaryText.Text = Format(existing?.VoltageRatio?.PrimaryNominal);
+        VoltageSecondaryText.Text = Format(existing?.VoltageRatio?.SecondaryNominal);
+        VoltageReferenceText.Text = existing?.VoltageRatio?.Reference ?? string.Empty;
+        NotesText.Text = existing?.Notes ?? string.Empty;
+        RemoveButton.IsEnabled = existing is not null;
+    }
+
+    public SvStreamMeasurementContext? ResultContext { get; private set; }
+    public bool RemoveRequested { get; private set; }
+
+    private void Apply_Click(object sender, RoutedEventArgs e)
+    {
+        try
+        {
+            var context = new SvStreamMeasurementContext
+            {
+                StreamKey = _streamKey,
+                SvId = _svId,
+                WireDomain = (SvMeasurementValueDomain)(WireDomainBox.SelectedItem
+                    ?? SvMeasurementValueDomain.PrimaryEngineering),
+                DisplayDomain = (SvMeasurementValueDomain)(DisplayDomainBox.SelectedItem
+                    ?? SvMeasurementValueDomain.PrimaryEngineering),
+                CurrentRatio = BuildRatio(
+                    CurrentPrimaryText.Text,
+                    CurrentSecondaryText.Text,
+                    "A",
+                    (SvRatioSource)(CurrentSourceBox.SelectedItem ?? SvRatioSource.Manual),
+                    CurrentReferenceText.Text,
+                    "current"),
+                VoltageRatio = BuildRatio(
+                    VoltagePrimaryText.Text,
+                    VoltageSecondaryText.Text,
+                    "V",
+                    (SvRatioSource)(VoltageSourceBox.SelectedItem ?? SvRatioSource.Manual),
+                    VoltageReferenceText.Text,
+                    "voltage"),
+                Notes = NotesText.Text.Trim(),
+                UpdatedAt = DateTimeOffset.UtcNow
+            };
+
+            var errors = context.Validate();
+            if (errors.Count > 0)
+                throw new InvalidDataException(string.Join("\n", errors));
+
+            ResultContext = context;
+            DialogResult = true;
+        }
+        catch (Exception ex) when (ex is FormatException or InvalidDataException or OverflowException)
+        {
+            MessageBox.Show(
+                this,
+                ex.Message,
+                "Invalid measurement context",
+                MessageBoxButton.OK,
+                MessageBoxImage.Warning);
+        }
+    }
+
+    private void Remove_Click(object sender, RoutedEventArgs e)
+    {
+        RemoveRequested = true;
+        ResultContext = null;
+        DialogResult = true;
+    }
+
+    private void Cancel_Click(object sender, RoutedEventArgs e)
+        => DialogResult = false;
+
+    private static SvMeasurementRatio? BuildRatio(
+        string primaryText,
+        string secondaryText,
+        string unit,
+        SvRatioSource source,
+        string reference,
+        string label)
+    {
+        var primaryBlank = string.IsNullOrWhiteSpace(primaryText);
+        var secondaryBlank = string.IsNullOrWhiteSpace(secondaryText);
+        if (primaryBlank && secondaryBlank)
+            return null;
+        if (primaryBlank || secondaryBlank)
+            throw new FormatException($"Both primary and secondary nominal values are required for the {label} ratio.");
+
+        var primary = ParsePositive(primaryText, $"{label} primary nominal");
+        var secondary = ParsePositive(secondaryText, $"{label} secondary nominal");
+        return new SvMeasurementRatio
+        {
+            PrimaryNominal = primary,
+            SecondaryNominal = secondary,
+            Unit = unit,
+            Source = source,
+            Reference = reference.Trim()
+        };
+    }
+
+    private static double ParsePositive(string text, string label)
+    {
+        if (!double.TryParse(text, NumberStyles.Float, CultureInfo.CurrentCulture, out var value) &&
+            !double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value))
+            throw new FormatException($"{label} is not a valid number.");
+        if (!double.IsFinite(value) || value <= 0)
+            throw new FormatException($"{label} must be a positive finite number.");
+        return value;
+    }
+
+    private static string Format(double? value)
+        => value.HasValue ? value.Value.ToString("0.########", CultureInfo.CurrentCulture) : string.Empty;
+}
diff --git a/src/ARSVIN.Subscriber/Models/DecodedValueRow.cs b/src/ARSVIN.Subscriber/Models/DecodedValueRow.cs
index c4c64ac..92e3400 100644
--- a/src/ARSVIN.Subscriber/Models/DecodedValueRow.cs
+++ b/src/ARSVIN.Subscriber/Models/DecodedValueRow.cs
@@ -13,13 +13,17 @@ public sealed class DecodedValueRow
     /// <summary>Decoded protocol number before any engineering scaling.</summary>
     public double? NumericValue { get; init; }
 
-    /// <summary>Primary engineering value when scaling evidence is sufficient.</summary>
+    /// <summary>Engineering value produced by protocol/profile scaling.</summary>
     public double? EngineeringValue { get; init; }
     public string EngineeringUnit { get; init; } = string.Empty;
     public SvEngineeringScaleSource ScalingSource { get; init; } = SvEngineeringScaleSource.RawOnly;
     public SvEngineeringScaleConfidence ScalingConfidence { get; init; } = SvEngineeringScaleConfidence.Unknown;
     public string ScalingReason { get; init; } = string.Empty;
 
+    /// <summary>Optional explicit primary/secondary interpretation supplied by measurement context.</summary>
+    public SvMeasurementDomainValue? DomainValue { get; init; }
+    public SvMeasurementValueDomain PreferredDisplayDomain { get; init; } = SvMeasurementValueDomain.Unknown;
+
     public bool HasEngineeringValue => EngineeringValue.HasValue && ScalingSource != SvEngineeringScaleSource.RawOnly;
     public bool IsQuality => Kind.Contains("Quality", StringComparison.OrdinalIgnoreCase);
     public SvQualityState? QualityState => IsQuality && SvQualityDecoder.TryDecodeHex(Raw, out var quality)
@@ -34,12 +38,31 @@ public string DisplayValue
         {
             if (QualityState is { } quality)
                 return quality.Summary;
+            if (TryResolvePreferredDisplay(out var value, out var unit))
+                return $"{value:0.###} {unit}".TrimEnd();
             return HasEngineeringValue
-                ? $"{EngineeringValue:0.###} {EngineeringUnit}"
+                ? $"{EngineeringValue:0.###} {EngineeringUnit}".TrimEnd()
                 : Value;
         }
     }
 
+    public string MeasurementDomainText
+    {
+        get
+        {
+            if (QualityState is not null)
+                return "Quality";
+            if (DomainValue is null)
+                return HasEngineeringValue ? "Engineering" : "Raw";
+
+            if (PreferredDisplayDomain == SvMeasurementValueDomain.PrimaryEngineering && DomainValue.PrimaryValue.HasValue)
+                return "Primary";
+            if (PreferredDisplayDomain == SvMeasurementValueDomain.SecondaryEquivalent && DomainValue.SecondaryEquivalentValue.HasValue)
+                return "Secondary";
+            return $"{DomainValue.WireDomain} fallback";
+        }
+    }
+
     public string ScalingText
     {
         get
@@ -47,8 +70,41 @@ public string ScalingText
             if (QualityState is { } quality)
                 return $"Quality · {quality.Severity} · {quality.Placement}";
             return HasEngineeringValue
-                ? $"{ScalingConfidence} · {ScalingSource}"
+                ? $"{ScalingConfidence} · {ScalingSource} · {MeasurementDomainText}"
                 : "Raw counts";
         }
     }
+
+    private bool TryResolvePreferredDisplay(out double value, out string unit)
+    {
+        value = 0;
+        unit = EngineeringUnit;
+        if (DomainValue is null)
+            return false;
+
+        if (PreferredDisplayDomain == SvMeasurementValueDomain.PrimaryEngineering &&
+            DomainValue.PrimaryValue.HasValue)
+        {
+            value = DomainValue.PrimaryValue.Value;
+            unit = DomainValue.Unit;
+            return true;
+        }
+
+        if (PreferredDisplayDomain == SvMeasurementValueDomain.SecondaryEquivalent &&
+            DomainValue.SecondaryEquivalentValue.HasValue)
+        {
+            value = DomainValue.SecondaryEquivalentValue.Value;
+            unit = DomainValue.Unit;
+            return true;
+        }
+
+        if (DomainValue.WireDomain is SvMeasurementValueDomain.PrimaryEngineering or SvMeasurementValueDomain.SecondaryEquivalent)
+        {
+            value = DomainValue.WireValue;
+            unit = DomainValue.Unit;
+            return true;
+        }
+
+        return false;
+    }
 }
diff --git a/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs b/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
index 3fd00e7..19f9b8d 100644
--- a/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
+++ b/src/ARSVIN.Subscriber/ViewModels/SvStreamViewModel.cs
@@ -4,12 +4,13 @@
 
 namespace ARSVIN.Subscriber.ViewModels;
 
-public sealed class SvStreamViewModel : ObservableObject
+public sealed partial class SvStreamViewModel : ObservableObject
 {
     private readonly BulkObservableCollection<DecodedValueRow> _values = new();
     private readonly BulkObservableCollection<WaveformPoint> _waveformPoints = new();
     private readonly BulkObservableCollection<PhasorVector> _phasors = new();
     private readonly BulkObservableCollection<string> _evidenceDetails = new();
+    private SvStreamMeasurementContext? _activeMeasurementContext;
     private string _key = string.Empty;
     private string _health = "IDLE";
     private string _healthDetail = string.Empty;
@@ -42,11 +43,13 @@ public sealed class SvStreamViewModel : ObservableObject
     private string _waveformState = "Waiting for a resolved timebase";
     private string _scaling = "Raw counts";
     private string _timebase = "Unknown";
+    private string _measurementContext = "No explicit CT/VT context";
 
     public IReadOnlyList<DecodedValueRow> Values => _values;
     public IReadOnlyList<WaveformPoint> WaveformPoints => _waveformPoints;
     public IReadOnlyList<PhasorVector> Phasors => _phasors;
     public IReadOnlyList<string> EvidenceDetails => _evidenceDetails;
+    public SvStreamMeasurementContext? ActiveMeasurementContext => _activeMeasurementContext;
 
     public string Key { get => _key; set => SetProperty(ref _key, value); }
     public string Health { get => _health; set => SetProperty(ref _health, value); }
@@ -80,9 +83,26 @@ public sealed class SvStreamViewModel : ObservableObject
     public string WaveformState { get => _waveformState; set => SetProperty(ref _waveformState, value); }
     public string Scaling { get => _scaling; set => SetProperty(ref _scaling, value); }
     public string Timebase { get => _timebase; set => SetProperty(ref _timebase, value); }
+    public string MeasurementContext { get => _measurementContext; set => SetProperty(ref _measurementContext, value); }
+
+    public void SetMeasurementContext(SvStreamMeasurementContext? context)
+    {
+        _activeMeasurementContext = context;
+        MeasurementContext = context?.Summary ?? "No explicit CT/VT context · displaying wire engineering domain";
+    }
 
     public void Apply(SvStreamSnapshot snapshot, SvStreamObservationSnapshot? observation)
+        => Apply(snapshot, observation, _activeMeasurementContext);
+
+    public void Apply(
+        SvStreamSnapshot snapshot,
+        SvStreamObservationSnapshot? observation,
+        SvStreamMeasurementContext? measurementContext)
     {
+        if (measurementContext is not null)
+            _activeMeasurementContext = measurementContext;
+        var effectiveContext = measurementContext ?? _activeMeasurementContext;
+
         Key = snapshot.Key;
         AppId = $"0x{snapshot.AppId:X4}";
         SvId = string.IsNullOrWhiteSpace(snapshot.SvId) ? "-" : snapshot.SvId;
@@ -102,8 +122,13 @@ public void Apply(SvStreamSnapshot snapshot, SvStreamObservationSnapshot? observ
         CursorSummary = snapshot.CursorSummary;
         Scaling = snapshot.ScalingSummary;
         Timebase = BuildTimebaseText(snapshot);
+        MeasurementContext = effectiveContext?.Summary ?? "No explicit CT/VT context · displaying wire engineering domain";
 
-        var qualityStates = ResolveQualityStates(snapshot.Values);
+        var displayValues = snapshot.Values
+            .Take(64)
+            .Select(value => ApplyMeasurementContext(value, effectiveContext))
+            .ToArray();
+        var qualityStates = ResolveQualityStates(displayValues);
         QualitySummary = BuildQualitySummary(qualityStates, snapshot.QualitySummary);
 
         var comparison = observation?.ConfigurationComparison;
@@ -147,36 +172,155 @@ public void Apply(SvStreamSnapshot snapshot, SvStreamObservationSnapshot? observ
         var samples = ResolveObservationSamples(observation?.Facts);
         Window = $"{duration:0.0} s · {samples:N0} samples";
 
-        _values.ReplaceAll(snapshot.Values.Take(64));
-        UpdateStableVisuals(snapshot);
-        _evidenceDetails.ReplaceAll(BuildEvidenceDetails(snapshot, observation, qualityStates));
+        _values.ReplaceAll(displayValues);
+        UpdateStableVisuals(snapshot, effectiveContext);
+        _evidenceDetails.ReplaceAll(BuildEvidenceDetails(snapshot, observation, qualityStates, effectiveContext));
     }
 
-    private void UpdateStableVisuals(SvStreamSnapshot snapshot)
+    private void UpdateStableVisuals(
+        SvStreamSnapshot snapshot,
+        SvStreamMeasurementContext? measurementContext)
     {
+        var convertedWaveform = ConvertWaveform(snapshot.WaveformPoints, measurementContext);
+        var convertedPhasors = ConvertPhasors(snapshot.Phasors, measurementContext);
+        var domainSuffix = measurementContext is null
+            ? string.Empty
+            : $" · display {measurementContext.DisplayDomain}";
+
         if (snapshot.SamplesPerCycle is not > 0)
         {
-            _waveformPoints.ReplaceAll(snapshot.WaveformPoints);
+            _waveformPoints.ReplaceAll(convertedWaveform);
             _phasors.ReplaceAll(Array.Empty<PhasorVector>());
-            WaveformState = $"{snapshot.ScalingSummary} · timebase unresolved; phasor withheld";
+            WaveformState = $"{snapshot.ScalingSummary}{domainSuffix} · timebase unresolved; phasor withheld";
             return;
         }
 
         var expectedPoints = Math.Clamp(snapshot.SamplesPerCycle.Value * 2, 32, 512);
-        var fullWindow = snapshot.IsWaveformWindowReady && snapshot.WaveformPoints.Count >= expectedPoints;
+        var fullWindow = snapshot.IsWaveformWindowReady && convertedWaveform.Count >= expectedPoints;
         if (fullWindow)
         {
-            _waveformPoints.ReplaceAll(snapshot.WaveformPoints.TakeLast(expectedPoints));
-            _phasors.ReplaceAll(snapshot.Phasors);
-            WaveformState = $"2 cycles locked · {expectedPoints:N0} points · {snapshot.ScalingSummary}";
+            _waveformPoints.ReplaceAll(convertedWaveform.TakeLast(expectedPoints));
+            _phasors.ReplaceAll(convertedPhasors);
+            WaveformState = $"2 cycles locked · {expectedPoints:N0} points · {snapshot.ScalingSummary}{domainSuffix}";
             return;
         }
 
-        _waveformPoints.ReplaceAll(snapshot.WaveformPoints);
+        _waveformPoints.ReplaceAll(convertedWaveform);
         _phasors.ReplaceAll(Array.Empty<PhasorVector>());
-        WaveformState = $"Filling verified window · {snapshot.WaveformPoints.Count:N0}/{expectedPoints:N0} points";
+        WaveformState = $"Filling verified window · {convertedWaveform.Count:N0}/{expectedPoints:N0} points{domainSuffix}";
+    }
+
+    private static DecodedValueRow ApplyMeasurementContext(
+        DecodedValueRow source,
+        SvStreamMeasurementContext? context)
+    {
+        if (context is null || source.IsQuality || !source.HasEngineeringValue || !source.EngineeringValue.HasValue)
+            return source;
+
+        var ratio = context.ResolveRatio($"{source.Kind} {source.Signal}");
+        var domainValue = SvMeasurementDomainResolver.Resolve(
+            source.EngineeringValue.Value,
+            source.EngineeringUnit,
+            context.WireDomain,
+            ratio);
+
+        return new DecodedValueRow
+        {
+            Index = source.Index,
+            Signal = source.Signal,
+            Kind = source.Kind,
+            Value = source.Value,
+            Raw = source.Raw,
+            NumericValue = source.NumericValue,
+            EngineeringValue = source.EngineeringValue,
+            EngineeringUnit = source.EngineeringUnit,
+            ScalingSource = source.ScalingSource,
+            ScalingConfidence = source.ScalingConfidence,
+            ScalingReason = source.ScalingReason,
+            DomainValue = domainValue,
+            PreferredDisplayDomain = context.DisplayDomain
+        };
+    }
+
+    private static IReadOnlyList<WaveformPoint> ConvertWaveform(
+        IReadOnlyList<WaveformPoint> source,
+        SvStreamMeasurementContext? context)
+    {
+        if (context is null)
+            return source;
+
+        var currentMultiplier = ResolveDisplayMultiplier(context, context.CurrentRatio);
+        var voltageMultiplier = ResolveDisplayMultiplier(context, context.VoltageRatio);
+        if (currentMultiplier == 1.0 && voltageMultiplier == 1.0)
+            return source;
+
+        return source.Select(point => new WaveformPoint
+        {
+            Index = point.Index,
+            SampleCount = point.SampleCount,
+            CurrentUnit = point.CurrentUnit,
+            VoltageUnit = point.VoltageUnit,
+            ScalingSummary = $"{point.ScalingSummary} · {context.DisplayDomain}",
+            Ia = Scale(point.Ia, currentMultiplier, point.CurrentUnit),
+            Ib = Scale(point.Ib, currentMultiplier, point.CurrentUnit),
+            Ic = Scale(point.Ic, currentMultiplier, point.CurrentUnit),
+            In = Scale(point.In, currentMultiplier, point.CurrentUnit),
+            Va = Scale(point.Va, voltageMultiplier, point.VoltageUnit),
+            Vb = Scale(point.Vb, voltageMultiplier, point.VoltageUnit),
+            Vc = Scale(point.Vc, voltageMultiplier, point.VoltageUnit),
+            Vn = Scale(point.Vn, voltageMultiplier, point.VoltageUnit)
+        }).ToArray();
+    }
+
+    private static IReadOnlyList<PhasorVector> ConvertPhasors(
+        IReadOnlyList<PhasorVector> source,
+        SvStreamMeasurementContext? context)
+    {
+        if (context is null)
+            return source;
+
+        return source.Select(vector =>
+        {
+            var ratio = context.ResolveRatio($"{vector.Kind} {vector.Channel}");
+            var multiplier = ResolveDisplayMultiplier(context, ratio);
+            if (multiplier == 1.0 || string.Equals(vector.Unit, "count", StringComparison.OrdinalIgnoreCase))
+                return vector;
+
+            return new PhasorVector
+            {
+                Channel = vector.Channel,
+                Kind = vector.Kind,
+                Unit = vector.Unit,
+                Rms = vector.Rms * multiplier,
+                Peak = vector.Peak * multiplier,
+                AngleDegrees = vector.AngleDegrees,
+                IsValid = vector.IsValid,
+                InvalidReason = vector.InvalidReason
+            };
+        }).ToArray();
     }
 
+    private static double ResolveDisplayMultiplier(
+        SvStreamMeasurementContext context,
+        SvMeasurementRatio? ratio)
+    {
+        if (context.WireDomain == context.DisplayDomain || ratio?.IsValid != true)
+            return 1.0;
+        return context.WireDomain switch
+        {
+            SvMeasurementValueDomain.PrimaryEngineering when context.DisplayDomain == SvMeasurementValueDomain.SecondaryEquivalent
+                => ratio.SecondaryNominal / ratio.PrimaryNominal,
+            SvMeasurementValueDomain.SecondaryEquivalent when context.DisplayDomain == SvMeasurementValueDomain.PrimaryEngineering
+                => ratio.PrimaryNominal / ratio.SecondaryNominal,
+            _ => 1.0
+        };
+    }
+
+    private static double? Scale(double? value, double multiplier, string unit)
+        => value.HasValue && !string.Equals(unit, "count", StringComparison.OrdinalIgnoreCase)
+            ? value.Value * multiplier
+            : value;
+
     private static string BuildSampleRateText(SvStreamSnapshot snapshot)
     {
         var declared = snapshot.SampleRate?.ToString() ?? "-";
@@ -275,16 +419,23 @@ private static string BuildQualitySummary(
     private static IReadOnlyList<string> BuildEvidenceDetails(
         SvStreamSnapshot snapshot,
         SvStreamObservationSnapshot? observation,
-        IReadOnlyList<SvQualityState> qualityStates)
+        IReadOnlyList<SvQualityState> qualityStates,
+        SvStreamMeasurementContext? measurementContext)
     {
         var lines = new List<string>
         {
             $"MEASUREMENT · scaling {snapshot.ScalingSummary} · {snapshot.ScalingReason}",
+            measurementContext is null
+                ? "MEASUREMENT CONTEXT · none · wire engineering values are shown without CT/VT conversion"
+                : $"MEASUREMENT CONTEXT · {measurementContext.Summary} · updated {measurementContext.UpdatedAt:O}",
             $"TIMEBASE · {BuildTimebaseText(snapshot)} · {snapshot.TimebaseReason}",
             $"HEALTH · current {snapshot.Health} · session totals gap {snapshot.SequenceGapCount}, duplicate {snapshot.DuplicateCount}, out-of-order {snapshot.OutOfOrderCount}, payload {snapshot.PayloadIssueCount}.",
             $"QUALITY · {BuildQualitySummary(qualityStates, snapshot.QualitySummary)}"
         };
 
+        if (!string.IsNullOrWhiteSpace(measurementContext?.Notes))
+            lines.Add($"MEASUREMENT CONTEXT NOTE · {measurementContext.Notes}");
+
         lines.AddRange(snapshot.Values
             .Where(value => value.IsQuality && value.QualityState is not null)
             .Select(value => $"QUALITY · {value.Signal} · {value.QualityState!.Severity} · {value.QualityState.Summary} · placement {value.QualityState.Placement} · raw {value.Raw}"));
diff --git a/tests/ARSVIN.Tests/SampledValuesMeasurementContextTests.cs b/tests/ARSVIN.Tests/SampledValuesMeasurementContextTests.cs
new file mode 100644
index 0000000..e242e1e
--- /dev/null
+++ b/tests/ARSVIN.Tests/SampledValuesMeasurementContextTests.cs
@@ -0,0 +1,128 @@
+using AR.Iec61850.SampledValues.Measurements;
+using Xunit;
+
+namespace ARSVIN.Tests;
+
+public sealed class SampledValuesMeasurementContextTests
+{
+    [Fact]
+    public void MeasurementContextRoundTripsWithExplicitRatios()
+    {
+        var document = new SvMeasurementContextDocument
+        {
+            ExportedAt = new DateTimeOffset(2026, 7, 22, 8, 30, 0, TimeSpan.Zero),
+            Streams =
+            [
+                new SvStreamMeasurementContext
+                {
+                    StreamKey = "01-0C-CD-04-00-01|4000|MU01|DS01",
+                    SvId = "MU01",
+                    WireDomain = SvMeasurementValueDomain.PrimaryEngineering,
+                    DisplayDomain = SvMeasurementValueDomain.SecondaryEquivalent,
+                    CurrentRatio = new SvMeasurementRatio
+                    {
+                        PrimaryNominal = 1_000,
+                        SecondaryNominal = 1,
+                        Unit = "A",
+                        Source = SvRatioSource.DeviceConfiguration,
+                        Reference = "SMU current input configuration"
+                    },
+                    VoltageRatio = new SvMeasurementRatio
+                    {
+                        PrimaryNominal = 20_000,
+                        SecondaryNominal = 100,
+                        Unit = "V",
+                        Source = SvRatioSource.DeviceConfiguration,
+                        Reference = "SMU voltage input configuration"
+                    },
+                    Notes = "Known injection evidence"
+                }
+            ]
+        };
+
+        var json = SvMeasurementContextSerializer.ToJson(document);
+        var restored = SvMeasurementContextSerializer.FromJson(json);
+
+        var context = Assert.Single(restored.Streams);
+        Assert.Equal("MU01", context.SvId);
+        Assert.Equal(SvMeasurementValueDomain.SecondaryEquivalent, context.DisplayDomain);
+        Assert.Equal(1_000, context.CurrentRatio!.PrimaryNominal);
+        Assert.Equal(100, context.VoltageRatio!.SecondaryNominal);
+        Assert.Contains("I 1000/1 A", context.Summary);
+    }
+
+    [Fact]
+    public void MeasurementContextRejectsDuplicateStreamKeys()
+    {
+        var context = new SvStreamMeasurementContext
+        {
+            StreamKey = "same-key",
+            SvId = "MU01"
+        };
+        var document = new SvMeasurementContextDocument
+        {
+            Streams = [context, context with { SvId = "MU02" }]
+        };
+
+        var error = Assert.Throws<InvalidDataException>(() =>
+            SvMeasurementContextSerializer.ToJson(document));
+
+        Assert.Contains("Duplicate measurement context", error.Message);
+    }
+
+    [Fact]
+    public void MeasurementContextRejectsWrongRatioUnit()
+    {
+        var document = new SvMeasurementContextDocument
+        {
+            Streams =
+            [
+                new SvStreamMeasurementContext
+                {
+                    StreamKey = "stream",
+                    CurrentRatio = new SvMeasurementRatio
+                    {
+                        PrimaryNominal = 1_000,
+                        SecondaryNominal = 1,
+                        Unit = "V",
+                        Source = SvRatioSource.Manual
+                    }
+                }
+            ]
+        };
+
+        var error = Assert.Throws<InvalidDataException>(() =>
+            SvMeasurementContextSerializer.ToJson(document));
+
+        Assert.Contains("current ratio unit must be A", error.Message);
+    }
+
+    [Fact]
+    public void ContextResolvesCurrentAndVoltageRatiosByChannelEvidence()
+    {
+        var current = new SvMeasurementRatio
+        {
+            PrimaryNominal = 1_000,
+            SecondaryNominal = 1,
+            Unit = "A",
+            Source = SvRatioSource.Manual
+        };
+        var voltage = new SvMeasurementRatio
+        {
+            PrimaryNominal = 20_000,
+            SecondaryNominal = 100,
+            Unit = "V",
+            Source = SvRatioSource.Manual
+        };
+        var context = new SvStreamMeasurementContext
+        {
+            StreamKey = "stream",
+            CurrentRatio = current,
+            VoltageRatio = voltage
+        };
+
+        Assert.Same(current, context.ResolveRatio("TCTR1/AmpSv.instMag.i"));
+        Assert.Same(voltage, context.ResolveRatio("TVTR1/VolSv.instMag.i"));
+        Assert.Null(context.ResolveRatio("UnknownChannel"));
+    }
+}