From 51888ec538aa71c7c12231c6a6fdcd322cb45191 Mon Sep 17 00:00:00 2001
From: Jackie Chen <nojackno2@hotmail.com.tw>
Date: Wed, 5 Aug 2026 20:34:40 +0800
Subject: [PATCH] feat: battery voltage history by charge level, sub-watt tray
 power (v1.1.6)

Records the battery driver's measured terminal voltage each time the integer
battery percentage changes, and plots the resulting 0-100% curve on a new
Battery Voltage History tab. Per-percentage average/min/max voltage, change
count and last-recorded time are persisted in LocalAppData and shown in an
exact-value table alongside the chart.

Unobserved percentages are left as gaps rather than interpolated, and a
voltage is only recorded when IsVoltageMeasured is true, so the internal
nominal voltage used for power math never reaches the curve.

Also fixes the tray icon rounding every rate to an integer, which rendered a
real 0.1-0.9 W flow as "0". Sub-watt rates now keep one decimal place; the
integer and "99+" rules above 1 W are unchanged.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 .github/release-notes/v1.1.6.md               |  27 +++
 AI_HANDOFF.md                                 |  91 +++++++-
 MainWindow.xaml                               |  90 +++++++-
 MainWindow.xaml.cs                            | 207 ++++++++++++++++++
 Models/BatteryVoltageHistoryPoint.cs          | 110 ++++++++++
 Services/BatteryVoltageHistoryService.cs      | 179 +++++++++++++++
 Services/DynamicTrayIconService.cs            |  22 +-
 Services/LocalizationService.cs               |  20 ++
 WinBatLens.csproj                             |  10 +-
 .../BatteryVoltageHistoryPointTests.cs        |  46 ++++
 .../TrayIconPowerFormattingTests.cs           |  24 ++
 11 files changed, 807 insertions(+), 19 deletions(-)
 create mode 100644 .github/release-notes/v1.1.6.md
 create mode 100644 Models/BatteryVoltageHistoryPoint.cs
 create mode 100644 Services/BatteryVoltageHistoryService.cs
 create mode 100644 tests/WinBatLens.Tests/BatteryVoltageHistoryPointTests.cs
 create mode 100644 tests/WinBatLens.Tests/TrayIconPowerFormattingTests.cs

diff --git a/.github/release-notes/v1.1.6.md b/.github/release-notes/v1.1.6.md
new file mode 100644
index 0000000..7fd7f3f
--- /dev/null
+++ b/.github/release-notes/v1.1.6.md
@@ -0,0 +1,27 @@
+## WinBat Lens v1.1.6
+
+This release adds a battery voltage curve recorded against state of charge, and
+fixes a tray icon that hid real sub-watt power flow.
+
+### Highlights
+
+- **New "Battery Voltage History" tab.** The monitor records the battery
+  driver's measured terminal voltage each time the integer battery percentage
+  changes, and plots the resulting 0–100% curve.
+- Per-percentage average, minimum and maximum voltage, change-event count and
+  last-recorded time are kept in an exact-value table alongside the chart, with
+  a clear action.
+- The history is persisted per user in LocalAppData, so the curve keeps
+  building across sessions.
+- Percentages that have never been observed are left as gaps in the curve
+  rather than interpolated — an unmeasured voltage is never drawn as if it had
+  been read.
+- Only voltages the battery driver actually reported are recorded. The internal
+  nominal voltage used for power math is excluded.
+- **Tray icon: sub-watt power is no longer rounded away.** A real charge or
+  discharge rate between 0.1 W and 0.9 W used to render as `0`, hiding the fact
+  that power was flowing. Rates below 1 W now show one decimal place; whole-watt
+  and `99+` display above 1 W is unchanged.
+
+The published executables are unsigned. Windows SmartScreen may show a warning
+on first launch.
diff --git a/AI_HANDOFF.md b/AI_HANDOFF.md
index f57e44a..1d56db1 100644
--- a/AI_HANDOFF.md
+++ b/AI_HANDOFF.md
@@ -1,10 +1,58 @@
 # Project State & Handoff
 
-## v1.1.5 release preparation (2026-08-05)
+## v1.1.6: battery voltage history by percentage (2026-08-05)
+
+Added a battery voltage history feature. The monitor records a real
+battery-driver voltage only when the integer battery percentage changes; the
+same percentage is ignored on subsequent one-second polls. The first
+observation seeds a percentage that has no prior record, while a percentage
+seen again after the battery moves is aggregated as another change event.
+
+`BatteryVoltageHistoryService` persists per-percentage average/minimum/maximum
+voltage, event count, and last timestamp in the user's LocalAppData. The new
+Battery Voltage History tab plots the observed 0-100% curve, leaves gaps for
+unmeasured percentages, and includes an exact-value table plus clear action.
+The chart never uses `RealTimePowerState.BatteryVoltageV` when
+`IsVoltageMeasured` is false, because that state can carry an internal nominal
+voltage used only for power math.
+
+Shipped together with the sub-watt tray icon fix below as **v1.1.6**; release
+notes are in `.github/release-notes/v1.1.6.md`.
+
+### Review pass before release
+
+Four defects were found and fixed in the new tab before publication, all in
+presentation rather than in the recorded measurements:
+
+1. **The vertical gridlines did not line up with the data.** They were drawn
+   across the whole container in tenths (`width/10*i`), but the curve is
+   plotted into an inset area (`plotLeft = 44`, `plotRight = 8`) that leaves
+   room for the Y-axis labels. `DrawVoltageChartGridlines` now takes
+   `plotLeft`/`plotWidth` and draws `i = 0..10` across the plot area, so a
+   gridline sits exactly under the percentage it marks and the plot's own
+   0%/100% edges are visible.
+2. **The 25% and 75% X-axis labels were in the wrong place.** Five equal
+   columns with the outer two edge-aligned put their centres at 30% and 70%.
+   The end columns are now `0.5*`, which lands every label on its true
+   position.
+3. **`LastRecordedAt` was bound raw**, so the column rendered a
+   culture-dependent `DateTime.ToString()` instead of the app's
+   `yyyy-MM-dd HH:mm:ss` convention. A `LastRecordedAtText` property was added
+   (and change-notified from `AddSample`) to match `PowerHistoryRecord`.
+4. **The XAML placeholder text and the samples-column header disagreed with
+   the localization strings** they are overwritten with at runtime — the header
+   said 樣本數 where the string is 變化次數, which is the more accurate name for
+   what is counted.
+
+Validation after the fixes: Debug and Release solution builds passed with
+`-warnaserror` at 0 warnings / 0 errors, `dotnet test` passed 17/17, and
+`git diff --check` passed.
+
+## v1.1.5 release and publication (2026-08-05)
 
 The post-v1.1.4 background-startup and comprehensive audit changes are being
-prepared for publication as v1.1.5. The project version is now 1.1.5 and the
-release notes are in `.github/release-notes/v1.1.5.md`.
+published as v1.1.5. The project version is 1.1.5 and the release notes are in
+`.github/release-notes/v1.1.5.md`.
 
 The intended release scope is the complete existing working-tree change set:
 background startup, tray warmup/idle behavior, removal of unsupported or dead
@@ -23,8 +71,31 @@ three assets; they are unsigned by design in this environment:
 - `WinBatLens_v1.1.5_Setup_x64.exe`: SHA-256
   `B4F5C013BA3F6CEAF1D1E917C068304A2CD993E3CB8FE90A2A830DAFA4DDA4B9`
 
-The ZIP contains `WinBatLens.exe`, `README.md`, and `LICENSE`. Publication to
-GitHub is the remaining step.
+The ZIP contains `WinBatLens.exe`, `README.md`, and `LICENSE`. PR #8 was merged
+to `main` at `c9fdbed`, tag `v1.1.5` triggered Release workflow run
+`30962533960`, and the normal GitHub Release is published at
+`https://github.com/nojackno2-ctrl/WinBat-Lens/releases/tag/v1.1.5`.
+
+The GitHub runner rebuilt the release assets, so the authoritative downloaded
+asset hashes are:
+
+- `WinBatLens_v1.1.5_Portable_x64.exe`: SHA-256
+  `1c8e0757439a0bde196149022bf048f6f7faf91574ff5496d640a07abaf798c9`
+- `WinBatLens_v1.1.5_Portable_x64.zip`: SHA-256
+  `1cdd0edf0908228021ef1ae34e0beec903c670fab2dc4b72ca889d16d6b35d2a`
+- `WinBatLens_v1.1.5_Setup_x64.exe`: SHA-256
+  `c66ca8fe3e8928240917a29d4df8a4364c2b1a3fe571fe443244fd973164cd76`
+
+## Sub-watt tray icon power display (2026-08-05)
+
+`DynamicTrayIconService` previously rounded every measured charge/discharge
+rate to an integer before drawing it. A real rate between 0.1W and 0.9W was
+therefore rendered as `0`, hiding the fact that power was flowing. The shared
+`FormatWattageForIcon` formatter now keeps one decimal place below 1W while
+preserving the existing integer and `99+` display rules at higher values.
+
+Added `TrayIconPowerFormattingTests` covering sub-watt, whole-watt, and
+overflow formatting. Released as part of v1.1.6.
 
 ## v1.1.4 released (latest)
 
@@ -131,10 +202,12 @@ run during this pass.
 
 ## Branch consolidation (2026-08-05)
 
-After refreshing `origin`, every branch had no commits outside `main`. The
-already-merged local `feat/show-version-and-handle-duplicate-launch` branch
-and remote `claude/memory-cpu-optimization-p0z5ve` branch were deleted. Only `main` remains locally and on `origin`; the working-tree audit changes remain
-uncommitted.
+After refreshing `origin`, `codex/v1.1.5-release` was confirmed to have no
+commits outside `main`; `main` already contained its release commit via the
+`c9fdbed` merge. The local and `origin` copies of that already-merged branch
+were deleted. Only `main` remains locally and on `origin`. The battery-voltage
+history and sub-watt tray-formatting changes in the working tree remain
+uncommitted and were preserved.
 
 ## Complete Traditional Chinese XML Documentation Pass (2026-08-05)
 
diff --git a/MainWindow.xaml b/MainWindow.xaml
index dead3f8..0ceda8d 100644
--- a/MainWindow.xaml
+++ b/MainWindow.xaml
@@ -505,7 +505,91 @@
                         </Grid>
                     </TabItem>
 
-                    <!-- TAB 3: Smart Diagnostics -->
+                    <!-- TAB 3: Battery Voltage by State of Charge (0–100%) -->
+                    <TabItem x:Name="TabVoltageHistory" Header=" 🔋 電池電壓紀錄 ">
+                        <Grid Margin="0,8,0,0">
+                            <Grid.RowDefinitions>
+                                <RowDefinition Height="Auto"/>
+                                <RowDefinition Height="270"/>
+                                <RowDefinition Height="*"/>
+                            </Grid.RowDefinitions>
+
+                            <Grid Grid.Row="0" Margin="0,0,0,7">
+                                <StackPanel>
+                                    <TextBlock x:Name="TxtVoltageHistoryTitle" Text="🔋 電池電壓紀錄（0–100%）" FontSize="13" FontWeight="Bold" Foreground="{StaticResource TextMain}"/>
+                                    <TextBlock x:Name="TxtVoltageHistorySummary" Text="已記錄 0 / 101 個電量區間，累積 0 次電量變化事件" FontSize="11" Foreground="{StaticResource TextMuted}" Margin="0,3,0,0"/>
+                                    <TextBlock x:Name="TxtVoltageHistoryHint" Text="僅顯示電池驅動回報的實測電壓；同一電量未變化時不重複記錄。" FontSize="11" Foreground="{StaticResource TextMuted}" Margin="0,2,0,0"/>
+                                </StackPanel>
+                                <Button x:Name="BtnClearVoltageHistory" Content="清除電壓紀錄" Style="{StaticResource SecondaryButtonStyle}" HorizontalAlignment="Right" VerticalAlignment="Center" Padding="10,4" Click="BtnClearVoltageHistory_Click"/>
+                            </Grid>
+
+                            <Border Grid.Row="1" Background="#182338" BorderBrush="{StaticResource BorderColor}" BorderThickness="1" CornerRadius="8" Padding="11,9" Margin="0,0,0,7">
+                                <Grid>
+                                    <Grid.RowDefinitions>
+                                        <RowDefinition Height="*"/>
+                                        <RowDefinition Height="Auto"/>
+                                    </Grid.RowDefinitions>
+
+                                    <Border Grid.Row="0" Background="#060910" BorderBrush="#1E293B" BorderThickness="1" CornerRadius="6" ClipToBounds="True">
+                                        <Grid x:Name="GridVoltageChartContainer" SizeChanged="GridVoltageChartContainer_SizeChanged">
+                                            <Canvas x:Name="CanvasVoltageGridlines"/>
+
+                                            <Grid VerticalAlignment="Stretch" HorizontalAlignment="Left" Margin="8,4,0,4" IsHitTestVisible="False">
+                                                <Grid.RowDefinitions>
+                                                    <RowDefinition Height="*"/>
+                                                    <RowDefinition Height="*"/>
+                                                    <RowDefinition Height="*"/>
+                                                    <RowDefinition Height="*"/>
+                                                    <RowDefinition Height="Auto"/>
+                                                </Grid.RowDefinitions>
+                                                <TextBlock x:Name="TxtVoltageYAxis100" Grid.Row="0" Text="-- V" FontSize="10" Foreground="#94A3B8" FontFamily="Consolas, Segoe UI" VerticalAlignment="Top"/>
+                                                <TextBlock x:Name="TxtVoltageYAxis75" Grid.Row="1" Text="-- V" FontSize="10" Foreground="#94A3B8" FontFamily="Consolas, Segoe UI" VerticalAlignment="Top"/>
+                                                <TextBlock x:Name="TxtVoltageYAxis50" Grid.Row="2" Text="-- V" FontSize="10" Foreground="#94A3B8" FontFamily="Consolas, Segoe UI" VerticalAlignment="Top"/>
+                                                <TextBlock x:Name="TxtVoltageYAxis25" Grid.Row="3" Text="-- V" FontSize="10" Foreground="#94A3B8" FontFamily="Consolas, Segoe UI" VerticalAlignment="Top"/>
+                                                <TextBlock x:Name="TxtVoltageYAxis0" Grid.Row="4" Text="-- V" FontSize="10" Foreground="#94A3B8" FontFamily="Consolas, Segoe UI" VerticalAlignment="Bottom"/>
+                                            </Grid>
+
+                                            <!-- Segments are split at missing percentages, so the line never
+                                                 implies a voltage that has not actually been observed. -->
+                                            <Canvas x:Name="CanvasVoltageLines" IsHitTestVisible="False"/>
+                                            <Canvas x:Name="CanvasVoltageMarkers" IsHitTestVisible="False"/>
+                                        </Grid>
+                                    </Border>
+
+                                    <!-- Half-width end columns so 25% / 50% / 75% land on their true
+                                         positions: five equal columns would centre them at 30% and 70%. -->
+                                    <Grid Grid.Row="1" Margin="44,3,8,0">
+                                        <Grid.ColumnDefinitions>
+                                            <ColumnDefinition Width="0.5*"/>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="*"/>
+                                            <ColumnDefinition Width="0.5*"/>
+                                        </Grid.ColumnDefinitions>
+                                        <TextBlock Text="0%" Grid.Column="0" FontSize="10" Foreground="{StaticResource TextMuted}" HorizontalAlignment="Left"/>
+                                        <TextBlock Text="25%" Grid.Column="1" FontSize="10" Foreground="{StaticResource TextMuted}" HorizontalAlignment="Center"/>
+                                        <TextBlock Text="50%" Grid.Column="2" FontSize="10" Foreground="{StaticResource TextMuted}" HorizontalAlignment="Center"/>
+                                        <TextBlock Text="75%" Grid.Column="3" FontSize="10" Foreground="{StaticResource TextMuted}" HorizontalAlignment="Center"/>
+                                        <TextBlock Text="100%" Grid.Column="4" FontSize="10" Foreground="{StaticResource TextMuted}" HorizontalAlignment="Right"/>
+                                    </Grid>
+                                </Grid>
+                            </Border>
+
+                            <ListView x:Name="LvBatteryVoltageHistory" Grid.Row="2" Background="#0C1322" BorderBrush="{StaticResource BorderColor}" BorderThickness="1" Foreground="{StaticResource TextMain}">
+                                <ListView.View>
+                                    <GridView>
+                                        <GridViewColumn x:Name="VoltagePercentColumn" Header="電量 (%)" Width="100" DisplayMemberBinding="{Binding BatteryPercentText}"/>
+                                        <GridViewColumn x:Name="VoltageAverageColumn" Header="平均電壓" Width="120" DisplayMemberBinding="{Binding AverageVoltageText}"/>
+                                        <GridViewColumn x:Name="VoltageRangeColumn" Header="實測範圍" Width="150" DisplayMemberBinding="{Binding VoltageRangeText}"/>
+                                        <GridViewColumn x:Name="VoltageSamplesColumn" Header="變化次數" Width="100" DisplayMemberBinding="{Binding SampleCount}"/>
+                                        <GridViewColumn x:Name="VoltageLastColumn" Header="最後紀錄" Width="170" DisplayMemberBinding="{Binding LastRecordedAtText}"/>
+                                    </GridView>
+                                </ListView.View>
+                            </ListView>
+                        </Grid>
+                    </TabItem>
+
+                    <!-- TAB 4: Smart Diagnostics -->
                     <TabItem x:Name="TabDiagnostics" Header=" 💡 智慧診斷與維護建議 ">
                         <ScrollViewer VerticalScrollBarVisibility="Auto" Margin="0,8,0,0">
                             <ItemsControl x:Name="IcDiagnostics">
@@ -523,7 +607,7 @@
                         </ScrollViewer>
                     </TabItem>
 
-                    <!-- TAB 4: Life Estimates -->
+                    <!-- TAB 5: Life Estimates -->
                     <TabItem x:Name="TabLifeEstimates" Header=" ⏱️ 續航估算表 ">
                         <ListView x:Name="LvLifeEstimates" Background="#0C1322" BorderBrush="{StaticResource BorderColor}" BorderThickness="1" Foreground="{StaticResource TextMain}" Margin="0,8,0,0">
                             <ListView.View>
@@ -536,7 +620,7 @@
                         </ListView>
                     </TabItem>
 
-                    <!-- TAB 5: Recent Usage -->
+                    <!-- TAB 6: Recent Usage -->
                     <TabItem x:Name="TabRecentUsage" Header=" 📊 最近使用紀錄 ">
                         <ListView x:Name="LvRecentUsage" Background="#0C1322" BorderBrush="{StaticResource BorderColor}" BorderThickness="1" Foreground="{StaticResource TextMain}" Margin="0,8,0,0">
                             <ListView.View>
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
index 92cab1f..b12c325 100644
--- a/MainWindow.xaml.cs
+++ b/MainWindow.xaml.cs
@@ -69,6 +69,7 @@ public partial class MainWindow : Window
         private readonly PointCollection _chargePoints = new PointCollection(MAX_CHART_POINTS);
         private readonly PointCollection _gpuPoints = new PointCollection(MAX_CHART_POINTS);
         private double _lastAxisScaleW = -1.0;
+        private static readonly SolidColorBrush BrushVoltage = CreateFrozen(MediaColor.FromRgb(0x38, 0xBD, 0xF8));
 
         // Frozen, shared brushes reused across timer ticks. UpdateLivePowerUI
         // runs once per second; allocating fresh SolidColorBrush objects every
@@ -190,6 +191,8 @@ private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
 
             // Bind Power History List
             LvPowerHistory.ItemsSource = RealTimePowerHistoryService.Records;
+            BatteryVoltageHistoryService.Load();
+            LvBatteryVoltageHistory.ItemsSource = BatteryVoltageHistoryService.Points;
 
             // Initialize System Tray Icon & AutoStart State
             InitSystemTrayIcon();
@@ -204,6 +207,7 @@ private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
 
             // Draw Background Gridlines
             DrawChartGridlines();
+            RedrawBatteryVoltageChart();
 
             await warmup;
 
@@ -253,6 +257,7 @@ private void ApplyLanguage()
             // Tabs
             TabRealTime.Header = LocalizationService.Get("TabRealTime");
             TabHistoryLogs.Header = LocalizationService.Get("TabHistoryLogs");
+            TabVoltageHistory.Header = LocalizationService.Get("TabVoltageHistory");
             TabDiagnostics.Header = LocalizationService.Get("TabDiagnostics");
             TabLifeEstimates.Header = LocalizationService.Get("TabLifeEstimates");
             TabRecentUsage.Header = LocalizationService.Get("TabRecentUsage");
@@ -265,6 +270,15 @@ private void ApplyLanguage()
             TxtLegendCharge.Text = LocalizationService.Get("LegendCharge");
             TxtLegendGpu.Text = LocalizationService.Get("LegendGpu");
 
+            TxtVoltageHistoryTitle.Text = LocalizationService.Get("VoltageHistoryTitle");
+            TxtVoltageHistoryHint.Text = LocalizationService.Get("VoltageHistoryHint");
+            BtnClearVoltageHistory.Content = LocalizationService.Get("BtnClearVoltageHistory");
+            VoltagePercentColumn.Header = LocalizationService.Get("VoltagePercentColumn");
+            VoltageAverageColumn.Header = LocalizationService.Get("VoltageAverageColumn");
+            VoltageRangeColumn.Header = LocalizationService.Get("VoltageRangeColumn");
+            VoltageSamplesColumn.Header = LocalizationService.Get("VoltageEventsColumn");
+            VoltageLastColumn.Header = LocalizationService.Get("VoltageLastColumn");
+
             TxtHardwareTitle.Text = LocalizationService.Get("HardwareTitle");
             LblHwBatteryTelemetry.Text = LocalizationService.Get("HwBatteryTelemetry");
             LblHwEnergy.Text = LocalizationService.Get("HwEnergy");
@@ -279,6 +293,167 @@ private void ApplyLanguage()
             if (_trayItemCheck != null) _trayItemCheck.Text = LocalizationService.Get("TrayCheck");
             if (_trayItemAutoStart != null) _trayItemAutoStart.Text = LocalizationService.Get("TrayAutoStart");
             if (_trayItemExit != null) _trayItemExit.Text = LocalizationService.Get("TrayExit");
+            RedrawBatteryVoltageChart();
+        }
+
+        private void GridVoltageChartContainer_SizeChanged(object sender, SizeChangedEventArgs e)
+        {
+            RedrawBatteryVoltageChart();
+        }
+
+        /// <summary>
+        /// Draws the voltage curve against a fixed 0–100% horizontal axis.
+        /// Missing percentages are left as gaps rather than being interpolated
+        /// into values that the battery driver never reported.
+        /// </summary>
+        private void RedrawBatteryVoltageChart()
+        {
+            try
+            {
+                int pointCount = BatteryVoltageHistoryService.RecordedPercentCount;
+                int eventCount = BatteryVoltageHistoryService.TotalSampleCount;
+                TxtVoltageHistorySummary.Text = string.Format(
+                    LocalizationService.Get("VoltageHistorySummary"),
+                    pointCount,
+                    eventCount);
+
+                CanvasVoltageGridlines.Children.Clear();
+                CanvasVoltageLines.Children.Clear();
+                CanvasVoltageMarkers.Children.Clear();
+
+                double width = GridVoltageChartContainer.ActualWidth;
+                double height = GridVoltageChartContainer.ActualHeight;
+                if (width <= 0 || height <= 0 || pointCount == 0)
+                {
+                    SetVoltageAxisLabels(null, null);
+                    return;
+                }
+
+                var points = BatteryVoltageHistoryService.Points;
+                double measuredMin = points.Min(point => point.AverageVoltageV);
+                double measuredMax = points.Max(point => point.AverageVoltageV);
+                double voltageSpan = Math.Max(1.0, measuredMax - measuredMin);
+                double padding = Math.Max(0.2, voltageSpan * 0.1);
+                double axisMin = Math.Floor((measuredMin - padding) * 10.0) / 10.0;
+                double axisMax = Math.Ceiling((measuredMax + padding) * 10.0) / 10.0;
+
+                if (axisMax - axisMin < 1.0)
+                {
+                    double center = (measuredMin + measuredMax) / 2.0;
+                    axisMin = Math.Floor((center - 0.5) * 10.0) / 10.0;
+                    axisMax = axisMin + 1.0;
+                }
+
+                const double plotLeft = 44.0;
+                const double plotRight = 8.0;
+                double plotWidth = Math.Max(1.0, width - plotLeft - plotRight);
+
+                DrawVoltageChartGridlines(plotLeft, plotWidth, width, height);
+                SetVoltageAxisLabels(axisMin, axisMax);
+
+                double axisRange = axisMax - axisMin;
+                Polyline? currentSegment = null;
+                int previousPercent = -2;
+
+                foreach (var item in points)
+                {
+                    double x = plotLeft + (item.BatteryPercent / 100.0 * plotWidth);
+                    double normalized = (item.AverageVoltageV - axisMin) / axisRange;
+                    double y = height - Math.Clamp(normalized, 0.0, 1.0) * height;
+
+                    // Only adjacent percentage events share a segment. A gap
+                    // in the curve therefore remains visibly unmeasured.
+                    if (item.BatteryPercent != previousPercent + 1)
+                    {
+                        currentSegment = new Polyline
+                        {
+                            Stroke = BrushVoltage,
+                            StrokeThickness = 2.5,
+                        };
+                        currentSegment.StrokeLineJoin = PenLineJoin.Round;
+                        CanvasVoltageLines.Children.Add(currentSegment);
+                    }
+
+                    currentSegment!.Points.Add(new WpfPoint(x, y));
+
+                    var marker = new System.Windows.Shapes.Ellipse
+                    {
+                        Width = 6,
+                        Height = 6,
+                        Fill = BrushVoltage,
+                        Stroke = BrushVoltage,
+                        StrokeThickness = 1
+                    };
+                    System.Windows.Controls.Canvas.SetLeft(marker, x - 3);
+                    System.Windows.Controls.Canvas.SetTop(marker, y - 3);
+                    CanvasVoltageMarkers.Children.Add(marker);
+                    previousPercent = item.BatteryPercent;
+                }
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Voltage chart redraw error: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Draws the voltage chart's background grid. The vertical divisions are
+        /// placed across the plot area rather than the whole container, so a
+        /// gridline sits exactly under the percentage it labels.
+        /// </summary>
+        private void DrawVoltageChartGridlines(double plotLeft, double plotWidth, double width, double height)
+        {
+            for (int i = 1; i <= 3; i++)
+            {
+                double y = (height / 4.0) * i;
+                CanvasVoltageGridlines.Children.Add(new Line
+                {
+                    X1 = 0,
+                    Y1 = y,
+                    X2 = width,
+                    Y2 = y,
+                    Stroke = BrushGridStrong,
+                    StrokeThickness = 1,
+                    StrokeDashArray = DashStrong
+                });
+            }
+
+            // 0% and 100% included: the plot area is inset from the container,
+            // so its own edges are not otherwise visible.
+            for (int i = 0; i <= 10; i++)
+            {
+                double x = plotLeft + (plotWidth / 10.0) * i;
+                CanvasVoltageGridlines.Children.Add(new Line
+                {
+                    X1 = x,
+                    Y1 = 0,
+                    X2 = x,
+                    Y2 = height,
+                    Stroke = BrushGridFaint,
+                    StrokeThickness = 1,
+                    StrokeDashArray = DashFaint
+                });
+            }
+        }
+
+        private void SetVoltageAxisLabels(double? axisMin, double? axisMax)
+        {
+            if (!axisMin.HasValue || !axisMax.HasValue)
+            {
+                TxtVoltageYAxis100.Text = "-- V";
+                TxtVoltageYAxis75.Text = "-- V";
+                TxtVoltageYAxis50.Text = "-- V";
+                TxtVoltageYAxis25.Text = "-- V";
+                TxtVoltageYAxis0.Text = "-- V";
+                return;
+            }
+
+            double range = axisMax.Value - axisMin.Value;
+            TxtVoltageYAxis100.Text = $"{axisMax.Value:F2} V";
+            TxtVoltageYAxis75.Text = $"{(axisMin.Value + range * 0.75):F2} V";
+            TxtVoltageYAxis50.Text = $"{(axisMin.Value + range * 0.50):F2} V";
+            TxtVoltageYAxis25.Text = $"{(axisMin.Value + range * 0.25):F2} V";
+            TxtVoltageYAxis0.Text = $"{axisMin.Value:F2} V";
         }
 
         private void GridChartContainer_SizeChanged(object sender, SizeChangedEventArgs e)
@@ -601,6 +776,7 @@ private void MainWindow_Closing(object? sender, System.ComponentModel.CancelEven
             // Real exit: Unloaded is not reliably raised for a top-level
             // Window, so stop the polling loop and release sensors/tray here.
             _livePowerCts?.Cancel();
+            BatteryVoltageHistoryService.Flush();
             try { HardwareSensorService.Shutdown(); } catch { }
             try { BatteryTelemetryService.Shutdown(); } catch { }
             try { PowerSupplyService.Shutdown(); } catch { }
@@ -797,6 +973,19 @@ private void UpdateLivePowerUI(RealTimePowerState state, bool recordSample = tru
                     // Add to Power & Battery Event History Service
                     RealTimePowerHistoryService.AddRecordFromPowerState(state);
 
+                    // Voltage history is event-based: a second-by-second poll
+                    // at the same battery percentage is intentionally ignored.
+                    bool voltageEventRecorded = false;
+                    if (state.IsVoltageMeasured)
+                    {
+                        voltageEventRecorded = BatteryVoltageHistoryService.RecordOnPercentChange(
+                            state.BatteryPercent,
+                            state.BatteryVoltageV,
+                            DateTime.Now);
+                    }
+                    if (voltageEventRecorded)
+                        RedrawBatteryVoltageChart();
+
                     // Update 60-Second Waveform Chart
                     UpdateWaveformChart(state);
                 }
@@ -1140,6 +1329,24 @@ private void BtnClearPowerHistory_Click(object sender, RoutedEventArgs e)
             }
         }
 
+        private void BtnClearVoltageHistory_Click(object sender, RoutedEventArgs e)
+        {
+            bool en = LocalizationService.CurrentLanguage == AppLanguage.English;
+            var result = MessageBox.Show(
+                en
+                    ? "Clear all battery voltage-by-percentage history?"
+                    : "要清除所有電量百分比與電壓紀錄嗎？",
+                en ? "Confirm Clear" : "確認清除",
+                MessageBoxButton.YesNo,
+                MessageBoxImage.Question);
+
+            if (result == MessageBoxResult.Yes)
+            {
+                BatteryVoltageHistoryService.Clear();
+                RedrawBatteryVoltageChart();
+            }
+        }
+
         private async void BtnGenerateReport_Click(object sender, RoutedEventArgs e)
         {
             await RunBatteryCheckAsync();
diff --git a/Models/BatteryVoltageHistoryPoint.cs b/Models/BatteryVoltageHistoryPoint.cs
new file mode 100644
index 0000000..0667904
--- /dev/null
+++ b/Models/BatteryVoltageHistoryPoint.cs
@@ -0,0 +1,110 @@
+using System;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Text.Json.Serialization;
+
+namespace WinBatLens.Models
+{
+    /// <summary>
+    /// 一個電量百分比的電池端實測電壓彙總。
+    /// </summary>
+    public sealed class BatteryVoltageHistoryPoint : INotifyPropertyChanged
+    {
+        private double _averageVoltageV;
+        private double _minimumVoltageV;
+        private double _maximumVoltageV;
+        private int _sampleCount;
+        private DateTime _lastRecordedAt;
+
+        /// <summary>電池電量百分比，範圍為 0–100。</summary>
+        public int BatteryPercent { get; set; }
+
+        /// <summary>此電量區間的平均實測電壓。</summary>
+        public double AverageVoltageV
+        {
+            get => _averageVoltageV;
+            set => SetField(ref _averageVoltageV, value);
+        }
+
+        /// <summary>此電量區間的最低實測電壓。</summary>
+        public double MinimumVoltageV
+        {
+            get => _minimumVoltageV;
+            set => SetField(ref _minimumVoltageV, value);
+        }
+
+        /// <summary>此電量區間的最高實測電壓。</summary>
+        public double MaximumVoltageV
+        {
+            get => _maximumVoltageV;
+            set => SetField(ref _maximumVoltageV, value);
+        }
+
+        /// <summary>此電量百分比累積的實測樣本數。</summary>
+        public int SampleCount
+        {
+            get => _sampleCount;
+            set => SetField(ref _sampleCount, value);
+        }
+
+        /// <summary>最後一次取得此電量區間電壓的時間。</summary>
+        public DateTime LastRecordedAt
+        {
+            get => _lastRecordedAt;
+            set => SetField(ref _lastRecordedAt, value);
+        }
+
+        [JsonIgnore]
+        public string BatteryPercentText => $"{BatteryPercent}%";
+
+        [JsonIgnore]
+        public string AverageVoltageText => $"{AverageVoltageV:F2} V";
+
+        [JsonIgnore]
+        public string VoltageRangeText => SampleCount > 1
+            ? $"{MinimumVoltageV:F2}–{MaximumVoltageV:F2} V"
+            : AverageVoltageText;
+
+        /// <summary>最後紀錄時間文字（格式 yyyy-MM-dd HH:mm:ss），與其他歷史清單一致。</summary>
+        [JsonIgnore]
+        public string LastRecordedAtText => LastRecordedAt.ToString("yyyy-MM-dd HH:mm:ss");
+
+        /// <summary>
+        /// 將一筆新的實測電壓加入此電量區間，並以累進平均避免保留大量原始樣本。
+        /// </summary>
+        public void AddSample(double voltageV, DateTime recordedAt)
+        {
+            if (!double.IsFinite(voltageV) || voltageV <= 0)
+                throw new ArgumentOutOfRangeException(nameof(voltageV));
+
+            if (SampleCount <= 0)
+            {
+                AverageVoltageV = voltageV;
+                MinimumVoltageV = voltageV;
+                MaximumVoltageV = voltageV;
+                SampleCount = 1;
+            }
+            else
+            {
+                AverageVoltageV += (voltageV - AverageVoltageV) / (SampleCount + 1);
+                MinimumVoltageV = Math.Min(MinimumVoltageV, voltageV);
+                MaximumVoltageV = Math.Max(MaximumVoltageV, voltageV);
+                SampleCount++;
+            }
+
+            LastRecordedAt = recordedAt;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(AverageVoltageText)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(VoltageRangeText)));
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(LastRecordedAtText)));
+        }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        private void SetField<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
+        {
+            if (Equals(field, value)) return;
+            field = value;
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}
diff --git a/Services/BatteryVoltageHistoryService.cs b/Services/BatteryVoltageHistoryService.cs
new file mode 100644
index 0000000..5f64aef
--- /dev/null
+++ b/Services/BatteryVoltageHistoryService.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using WinBatLens.Models;
+
+namespace WinBatLens.Services
+{
+    /// <summary>
+    /// 累積並保存「電量百分比 → 電池端電壓」的實測紀錄。
+    /// </summary>
+    public static class BatteryVoltageHistoryService
+    {
+        private const int CurrentFileVersion = 1;
+        private static readonly ObservableCollection<BatteryVoltageHistoryPoint> _points = new();
+        private static readonly string _historyDirectory = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "WinBatLens");
+        private static readonly string _historyFilePath = Path.Combine(
+            _historyDirectory,
+            "battery-voltage-history.json");
+
+        private static bool _loaded;
+        private static int? _lastObservedPercent;
+
+        /// <summary>依電量百分比遞增排序的歷史紀錄。</summary>
+        public static ReadOnlyObservableCollection<BatteryVoltageHistoryPoint> Points { get; } =
+            new ReadOnlyObservableCollection<BatteryVoltageHistoryPoint>(_points);
+
+        /// <summary>目前已記錄的電量百分比區間數。</summary>
+        public static int RecordedPercentCount => _points.Count;
+
+        /// <summary>目前累積的硬體實測樣本總數。</summary>
+        public static int TotalSampleCount => _points.Sum(point => Math.Max(0, point.SampleCount));
+
+        /// <summary>載入安裝版使用者的持久化電壓紀錄；損毀檔案會被忽略。</summary>
+        public static void Load()
+        {
+            if (_loaded) return;
+            _loaded = true;
+
+            try
+            {
+                if (!File.Exists(_historyFilePath)) return;
+
+                var file = JsonSerializer.Deserialize<HistoryFile>(
+                    File.ReadAllText(_historyFilePath));
+
+                if (file?.Version != CurrentFileVersion || file.Points == null) return;
+
+                foreach (var point in file.Points
+                    .Where(IsValidPoint)
+                    .OrderBy(point => point.BatteryPercent))
+                {
+                    _points.Add(point);
+                }
+
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Battery voltage history load failed: {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// 只在電量百分比變化時記錄一筆已確認為硬體實測的電壓。相同百分比
+        /// 的每秒輪詢會被忽略；不同充放電循環再次經過同一百分比時，才會
+        /// 將該次變化加入同一個百分比的彙總資料。
+        /// </summary>
+        /// <returns>若這次百分比變化已加入紀錄則回傳 true。</returns>
+        public static bool RecordOnPercentChange(int batteryPercent, double voltageV, DateTime? recordedAt = null)
+        {
+            if (batteryPercent is < 0 or > 100 || !double.IsFinite(voltageV) || voltageV <= 0)
+                return false;
+
+            Load();
+            bool isFirstObservation = !_lastObservedPercent.HasValue;
+            if (!HasPercentChanged(_lastObservedPercent, batteryPercent))
+                return false;
+
+            DateTime timestamp = recordedAt ?? DateTime.Now;
+            var point = _points.FirstOrDefault(item => item.BatteryPercent == batteryPercent);
+            _lastObservedPercent = batteryPercent;
+
+            // An existing point already represents this percentage from an
+            // earlier run. The first observation after a restart is not a
+            // percentage change, so do not create a duplicate event. Once the
+            // percentage moves and comes back, the event is recorded.
+            if (isFirstObservation && point != null)
+                return false;
+
+            if (point == null)
+            {
+                point = new BatteryVoltageHistoryPoint { BatteryPercent = batteryPercent };
+                int insertAt = 0;
+                while (insertAt < _points.Count && _points[insertAt].BatteryPercent < batteryPercent)
+                    insertAt++;
+                _points.Insert(insertAt, point);
+            }
+
+            point.AddSample(voltageV, timestamp);
+
+            // Percentage changes are infrequent compared with the one-second
+            // monitor loop, so each accepted event is durable immediately.
+            Persist();
+
+            return true;
+        }
+
+        /// <summary>判斷目前百分比是否與上一筆觀察不同。</summary>
+        internal static bool HasPercentChanged(int? lastObservedPercent, int currentPercent) =>
+            currentPercent is >= 0 and <= 100 &&
+            (!lastObservedPercent.HasValue || lastObservedPercent.Value != currentPercent);
+
+        /// <summary>清除畫面與磁碟上的所有電壓紀錄。</summary>
+        public static void Clear()
+        {
+            Load();
+            _points.Clear();
+            _lastObservedPercent = null;
+            Persist();
+        }
+
+        /// <summary>確保程式結束前把最近的彙總寫入磁碟。</summary>
+        public static void Flush()
+        {
+            Load();
+            Persist();
+        }
+
+        private static bool IsValidPoint(BatteryVoltageHistoryPoint point) =>
+            point != null &&
+            point.BatteryPercent is >= 0 and <= 100 &&
+            point.SampleCount > 0 &&
+            double.IsFinite(point.AverageVoltageV) && point.AverageVoltageV > 0 &&
+            double.IsFinite(point.MinimumVoltageV) && point.MinimumVoltageV > 0 &&
+            double.IsFinite(point.MaximumVoltageV) && point.MaximumVoltageV > 0 &&
+            point.MinimumVoltageV <= point.MaximumVoltageV;
+
+        private static void Persist()
+        {
+            try
+            {
+                Directory.CreateDirectory(_historyDirectory);
+                var file = new HistoryFile
+                {
+                    Version = CurrentFileVersion,
+                    SavedAt = DateTime.Now,
+                    Points = _points.ToList()
+                };
+                string json = JsonSerializer.Serialize(file, new JsonSerializerOptions
+                {
+                    WriteIndented = true
+                });
+                string tempPath = _historyFilePath + ".tmp";
+                File.WriteAllText(tempPath, json);
+
+                if (File.Exists(_historyFilePath))
+                    File.Replace(tempPath, _historyFilePath, null);
+                else
+                    File.Move(tempPath, _historyFilePath);
+
+            }
+            catch (Exception ex)
+            {
+                System.Diagnostics.Debug.WriteLine($"Battery voltage history save failed: {ex.Message}");
+            }
+        }
+
+        private sealed class HistoryFile
+        {
+            public int Version { get; set; }
+            public DateTime SavedAt { get; set; }
+            public List<BatteryVoltageHistoryPoint> Points { get; set; } = new();
+        }
+    }
+}
diff --git a/Services/DynamicTrayIconService.cs b/Services/DynamicTrayIconService.cs
index 483dd66..52da0dc 100644
--- a/Services/DynamicTrayIconService.cs
+++ b/Services/DynamicTrayIconService.cs
@@ -2,6 +2,7 @@
 using System.Drawing;
 using System.Drawing.Drawing2D;
 using System.Drawing.Text;
+using System.Globalization;
 using System.Runtime.InteropServices;
 using System.Windows.Forms;
 using WinBatLens.Models;
@@ -39,15 +40,13 @@ public static void UpdateTrayIcon(NotifyIcon notifyIcon, RealTimePowerState stat
                 if (state.IsCharging && state.IsChargeRateMeasured)
                 {
                     // 充電中：綠色顯示充電功率（如 56W）
-                    int wattVal = (int)Math.Round(state.ChargingRateW);
-                    textToDraw = wattVal > 99 ? "99+" : wattVal.ToString();
+                    textToDraw = FormatWattageForIcon(state.ChargingRateW);
                     textColor = Color.FromArgb(255, 16, 185, 129); // #10B981 翡翠綠
                 }
                 else if (state.IsDischargeRateMeasured)
                 {
                     // 放電中：紅色顯示放電功率（如 49W）
-                    int wattVal = (int)Math.Round(state.DischargeRateW);
-                    textToDraw = wattVal > 99 ? "99+" : wattVal.ToString();
+                    textToDraw = FormatWattageForIcon(state.DischargeRateW);
                     textColor = Color.FromArgb(255, 244, 63, 94); // #F43F5E 玫瑰紅
                 }
                 else
@@ -143,5 +142,20 @@ public static void Dispose()
             _lastDrawnText = null;
             _lastDrawnColor = default;
         }
+
+        /// <summary>
+        /// Formats tray-icon wattage. Keep sub-watt measurements visible with
+        /// one decimal place instead of rounding them to a misleading zero.
+        /// </summary>
+        internal static string FormatWattageForIcon(double watts)
+        {
+            if (watts < 1.0)
+            {
+                return watts.ToString("F1", CultureInfo.InvariantCulture);
+            }
+
+            int wattVal = (int)Math.Round(watts);
+            return wattVal > 99 ? "99+" : wattVal.ToString(CultureInfo.InvariantCulture);
+        }
     }
 }
diff --git a/Services/LocalizationService.cs b/Services/LocalizationService.cs
index 3b56f76..c096b9e 100644
--- a/Services/LocalizationService.cs
+++ b/Services/LocalizationService.cs
@@ -25,6 +25,16 @@ public class LocalizationService
 
         private static readonly Dictionary<string, string> ZhTwStrings = new Dictionary<string, string>
         {
+            ["TabVoltageHistory"] = " 🔋 電池電壓紀錄 ",
+            ["VoltageHistoryTitle"] = "🔋 電池電壓紀錄（0–100%）",
+            ["VoltageHistorySummary"] = "已記錄 {0} / 101 個電量區間，累積 {1} 次電量變化事件",
+            ["VoltageHistoryHint"] = "僅顯示電池驅動回報的實測電壓；同一電量未變化時不重複記錄。",
+            ["BtnClearVoltageHistory"] = "清除電壓紀錄",
+            ["VoltagePercentColumn"] = "電量 (%)",
+            ["VoltageAverageColumn"] = "平均電壓",
+            ["VoltageRangeColumn"] = "實測範圍",
+            ["VoltageEventsColumn"] = "變化次數",
+            ["VoltageLastColumn"] = "最後紀錄",
             ["AppTitle"] = "WinBat Lens - Windows 電池健康度與即時硬體耗電監測",
             ["SubTitle"] = "Windows 電池健康診斷與全系統耗電監測",
             ["AutoStart"] = "🚀 開機自動啟動",
@@ -95,6 +105,16 @@ public class LocalizationService
 
         private static readonly Dictionary<string, string> EnUsStrings = new Dictionary<string, string>
         {
+            ["TabVoltageHistory"] = " 🔋 Battery Voltage History ",
+            ["VoltageHistoryTitle"] = "🔋 Battery Voltage by Charge Level (0–100%)",
+            ["VoltageHistorySummary"] = "Recorded {0} / 101 charge-level ranges, {1} percentage-change events",
+            ["VoltageHistoryHint"] = "Only battery-driver measurements are shown; the same percentage is not recorded again until it changes.",
+            ["BtnClearVoltageHistory"] = "Clear Voltage History",
+            ["VoltagePercentColumn"] = "Battery (%)",
+            ["VoltageAverageColumn"] = "Average voltage",
+            ["VoltageRangeColumn"] = "Measured range",
+            ["VoltageEventsColumn"] = "Change events",
+            ["VoltageLastColumn"] = "Last recorded",
             ["AppTitle"] = "WinBat Lens - Windows Battery Health & Real-Time Hardware Power Monitor",
             ["SubTitle"] = "Windows Battery Health Diagnostics & Full System Power Monitor",
             ["AutoStart"] = "🚀 Launch on Windows Startup",
diff --git a/WinBatLens.csproj b/WinBatLens.csproj
index 1f0d558..95b0b24 100644
--- a/WinBatLens.csproj
+++ b/WinBatLens.csproj
@@ -13,9 +13,9 @@
     <Company>WinBat Lens</Company>
     <Product>WinBat Lens</Product>
     <Description>Windows 電池健康度視覺化儀表板與 powercfg /batteryreport 解析工具</Description>
-    <Version>1.1.5</Version>
-    <AssemblyVersion>1.1.5.0</AssemblyVersion>
-    <FileVersion>1.1.5.0</FileVersion>
+    <Version>1.1.6</Version>
+    <AssemblyVersion>1.1.6.0</AssemblyVersion>
+    <FileVersion>1.1.6.0</FileVersion>
 
     <!-- Memory tuning for a long-running background tray app -->
     <!-- Workstation (non-server) GC keeps a single small heap instead of one per CPU core -->
@@ -65,4 +65,8 @@
     <Resource Include="app_icon.png" />
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="WinBatLens.Tests" />
+  </ItemGroup>
+
 </Project>
diff --git a/tests/WinBatLens.Tests/BatteryVoltageHistoryPointTests.cs b/tests/WinBatLens.Tests/BatteryVoltageHistoryPointTests.cs
new file mode 100644
index 0000000..5ffccd5
--- /dev/null
+++ b/tests/WinBatLens.Tests/BatteryVoltageHistoryPointTests.cs
@@ -0,0 +1,46 @@
+using System;
+using WinBatLens.Models;
+using WinBatLens.Services;
+using Xunit;
+
+namespace WinBatLens.Tests;
+
+public sealed class BatteryVoltageHistoryPointTests
+{
+    [Fact]
+    public void AggregatesAverageRangeAndSampleCount()
+    {
+        var point = new BatteryVoltageHistoryPoint { BatteryPercent = 42 };
+        var first = new DateTime(2026, 8, 5, 12, 0, 0);
+        point.AddSample(12.10, first);
+        point.AddSample(12.30, first.AddSeconds(1));
+
+        Assert.Equal(42, point.BatteryPercent);
+        Assert.Equal(12.20, point.AverageVoltageV, 2);
+        Assert.Equal(12.10, point.MinimumVoltageV, 2);
+        Assert.Equal(12.30, point.MaximumVoltageV, 2);
+        Assert.Equal(2, point.SampleCount);
+        Assert.Equal(first.AddSeconds(1), point.LastRecordedAt);
+        Assert.Equal("12.10–12.30 V", point.VoltageRangeText);
+    }
+
+    [Theory]
+    [InlineData(0.0)]
+    [InlineData(-1.0)]
+    public void RejectsInvalidVoltage(double voltage)
+    {
+        var point = new BatteryVoltageHistoryPoint { BatteryPercent = 42 };
+
+        Assert.Throws<ArgumentOutOfRangeException>(() => point.AddSample(voltage, DateTime.Now));
+    }
+
+    [Theory]
+    [InlineData(50, 50, false)]
+    [InlineData(50, 49, true)]
+    [InlineData(50, 51, true)]
+    [InlineData(null, 50, true)]
+    public void RecordsOnlyWhenBatteryPercentChanges(int? previous, int current, bool expected)
+    {
+        Assert.Equal(expected, BatteryVoltageHistoryService.HasPercentChanged(previous, current));
+    }
+}
diff --git a/tests/WinBatLens.Tests/TrayIconPowerFormattingTests.cs b/tests/WinBatLens.Tests/TrayIconPowerFormattingTests.cs
new file mode 100644
index 0000000..de07c6d
--- /dev/null
+++ b/tests/WinBatLens.Tests/TrayIconPowerFormattingTests.cs
@@ -0,0 +1,24 @@
+using WinBatLens.Services;
+using Xunit;
+
+namespace WinBatLens.Tests;
+
+public sealed class TrayIconPowerFormattingTests
+{
+    [Theory]
+    [InlineData(0.1, "0.1")]
+    [InlineData(0.9, "0.9")]
+    public void KeepsSubWattPowerVisible(double watts, string expected)
+    {
+        Assert.Equal(expected, DynamicTrayIconService.FormatWattageForIcon(watts));
+    }
+
+    [Theory]
+    [InlineData(1.4, "1")]
+    [InlineData(49.6, "50")]
+    [InlineData(100.0, "99+")]
+    public void KeepsWholeWattAndOverflowFormatting(double watts, string expected)
+    {
+        Assert.Equal(expected, DynamicTrayIconService.FormatWattageForIcon(watts));
+    }
+}