diff --git a/Lite.Tests/OverviewBlockingLaneDataStartLiveTests.cs b/Lite.Tests/OverviewBlockingLaneDataStartLiveTests.cs
new file mode 100644
index 0000000000..ce7ec2ac3f
--- /dev/null
+++ b/Lite.Tests/OverviewBlockingLaneDataStartLiveTests.cs
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Lite.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using DuckDB.NET.Data;
+using PerformanceMonitorLite.Controls;
+using PerformanceMonitorLite.Database;
+using PerformanceMonitorLite.Services;
+using Xunit;
+
+namespace PerformanceMonitorLite.Tests;
+
+/// <summary>
+/// The Overview blocking chart's "Showing since" note (#4966) against a real store, through the same step the control runs
+/// (<see cref="LiteBlockingLaneDataStart.ShowAsync"/>): the notice, the quiet start, one series answering, a failed probe and a short window.
+/// Anchors are fixed so the tests never straddle a day boundary.
+/// </summary>
+[Collection("server-time-helper")]
+public sealed class OverviewBlockingLaneDataStartLiveTests : IDisposable
+{
+    private const int ServerId = 4966;
+    private const string ServerName = "OverviewBlockingServer";
+    private static readonly DateTime End = new(2026, 9, 20, 12, 0, 0, DateTimeKind.Unspecified);
+    private readonly string _tempDir;
+    private readonly DuckDbInitializer _duckDb;
+    private long _nextId = 1;
+
+    public OverviewBlockingLaneDataStartLiveTests()
+    {
+        _tempDir = Path.Combine(Path.GetTempPath(), "OverviewBlockingLane_" + Guid.NewGuid().ToString("N")[..8]);
+        Directory.CreateDirectory(_tempDir);
+        _duckDb = new DuckDbInitializer(Path.Combine(_tempDir, "test.duckdb"));
+    }
+
+    public void Dispose()
+    {
+        try { if (Directory.Exists(_tempDir)) Directory.Delete(_tempDir, recursive: true); }
+        catch { /* best-effort cleanup */ }
+    }
+
+    private static string CollectorOf(QueryWindowRelation relation) =>
+        relation == QueryWindowRelation.BlockedProcessReports ? "blocked_process_report" : "deadlocks";
+
+    private async Task SeedLogRunsAsync(QueryWindowRelation relation, DateTime firstUtc, DateTime lastUtc)
+    {
+        using var connection = _duckDb.CreateConnection();
+        await connection.OpenAsync();
+        using var readLock = _duckDb.AcquireReadLock();
+        using var cmd = connection.CreateCommand();
+        cmd.CommandText = @"
+INSERT INTO collection_log (log_id, server_id, server_name, collector_name, collection_time, duration_ms, status, rows_collected)
+SELECT $1 + row_number() OVER (), $2, $3, $4, g.t, 12, 'SUCCESS', 0
+FROM generate_series($5::TIMESTAMP, $6::TIMESTAMP, INTERVAL 30 MINUTE) AS g(t)";
+        cmd.Parameters.Add(new DuckDBParameter { Value = _nextId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = ServerName });
+        cmd.Parameters.Add(new DuckDBParameter { Value = CollectorOf(relation) });
+        cmd.Parameters.Add(new DuckDBParameter { Value = firstUtc });
+        cmd.Parameters.Add(new DuckDBParameter { Value = lastUtc });
+        _nextId += await cmd.ExecuteNonQueryAsync() + 1;
+    }
+
+    private static string SinceText(DateTime instant) =>
+        "Showing since " + PerformanceMonitor.Ui.DisplayZone.Format(instant, TimeZoneInfo.Utc, "yyyy-MM-dd HH:mm:ss");
+
+    private static TrendPoint Bar(DateTime at, int count = 1) => new() { Time = at, Count = count };
+
+    private async Task<(bool Visible, string Text)> NoteAsync(
+        DateTime startUtc, DateTime endUtc, IEnumerable<TrendPoint> blockingBars, IEnumerable<TrendPoint> deadlockBars,
+        Func<QueryWindowRelation, Task<DateTime?>>? floorOf = null)
+    {
+        var service = new LocalDataService(_duckDb);
+        floorOf ??= relation => service.GetQueryWindowFloorAsync(relation, ServerId, startUtc, endUtc);
+        /* The real note step, end to end, on an STA thread: the banner is a WPF object. No sync context there, so the blocking wait is safe. */
+        return OnStaThread(() =>
+        {
+            var banner = new System.Windows.Controls.TextBlock();
+            LiteBlockingLaneDataStart.ShowAsync(banner, floorOf, startUtc, endUtc, blockingBars, deadlockBars, TimeZoneInfo.Utc).GetAwaiter().GetResult();
+            return (banner.Visibility == System.Windows.Visibility.Visible, banner.Text);
+        });
+    }
+
+    /// <summary>Blocking was collected from 2 days back, deadlocks from 3: the one note names the later start, in the chart's zone.</summary>
+    [Fact]
+    public async Task Notice_NamesTheLaterOfTheTwoSeriesStarts()
+    {
+        await _duckDb.InitializeAsync();
+        var blockingFrom = End.AddDays(-2);
+        await SeedLogRunsAsync(QueryWindowRelation.BlockedProcessReports, blockingFrom, End);
+        await SeedLogRunsAsync(QueryWindowRelation.Deadlocks, End.AddDays(-3), End);
+
+        var (visible, text) = await NoteAsync(End.AddDays(-7), End, [], []);
+
+        Assert.True(visible);
+        Assert.Equal(SinceText(blockingFrom), text);
+    }
+
+    /// <summary>Both collectors ran across the whole range and the first bars come late: no note, and a zero bucket changes nothing.</summary>
+    [Fact]
+    public async Task QuietStart_BothCollectorsCoveredTheRange_ShowsNoNote()
+    {
+        await _duckDb.InitializeAsync();
+        await SeedLogRunsAsync(QueryWindowRelation.BlockedProcessReports, End.AddDays(-9), End);
+        await SeedLogRunsAsync(QueryWindowRelation.Deadlocks, End.AddDays(-9), End);
+
+        var (visible, text) = await NoteAsync(
+            End.AddDays(-7), End, [Bar(End.AddDays(-7).AddHours(5)), Bar(End.AddHours(-1))], [Bar(End.AddDays(-7), 0), Bar(End.AddHours(-2))]);
+
+        Assert.False(visible);
+        Assert.Equal(string.Empty, text);
+    }
+
+    /// <summary>One collector covers the range and the other began 2 days ago: the later start is named, not the covered one.</summary>
+    [Fact]
+    public async Task OneSeriesCovered_TheOtherStartedLate_NamesTheLateOne()
+    {
+        await _duckDb.InitializeAsync();
+        var lateFrom = End.AddDays(-2);
+        await SeedLogRunsAsync(QueryWindowRelation.BlockedProcessReports, End.AddDays(-9), End);
+        await SeedLogRunsAsync(QueryWindowRelation.Deadlocks, lateFrom, End);
+
+        var (visible, text) = await NoteAsync(End.AddDays(-7), End, [], []);
+
+        Assert.True(visible);
+        Assert.Equal(SinceText(lateFrom), text);
+    }
+
+    /// <summary>A probe that throws costs only its own series' start; the other still names the note.</summary>
+    [Fact]
+    public async Task AFailedProbe_CostsOnlyItsSeries()
+    {
+        await _duckDb.InitializeAsync();
+        var from = End.AddDays(-2);
+        await SeedLogRunsAsync(QueryWindowRelation.Deadlocks, from, End);
+        var service = new LocalDataService(_duckDb);
+
+        var (visible, text) = await NoteAsync(End.AddDays(-7), End, [], [],
+            relation => relation == QueryWindowRelation.BlockedProcessReports
+                ? Task.FromException<DateTime?>(new InvalidOperationException("probe failed"))
+                : service.GetQueryWindowFloorAsync(relation, ServerId, End.AddDays(-7), End));
+
+        Assert.True(visible);
+        Assert.Equal(SinceText(from), text);
+    }
+
+    /// <summary>A failed blocking probe with a late bar names no start; the covered deadlock series starts at the window start, so no note.</summary>
+    [Fact]
+    public async Task AFailedProbe_WithALateBar_AndACoveredOtherSeries_ShowsNoNote()
+    {
+        await _duckDb.InitializeAsync();
+        await SeedLogRunsAsync(QueryWindowRelation.Deadlocks, End.AddDays(-9), End);
+        var service = new LocalDataService(_duckDb);
+
+        var (visible, text) = await NoteAsync(End.AddDays(-7), End, [Bar(End.AddHours(-1))], [],
+            relation => relation == QueryWindowRelation.BlockedProcessReports
+                ? Task.FromException<DateTime?>(new InvalidOperationException("probe failed"))
+                : service.GetQueryWindowFloorAsync(relation, ServerId, End.AddDays(-7), End));
+
+        Assert.False(visible);
+        Assert.Equal(string.Empty, text);
+    }
+
+    /// <summary>A window of 90 minutes or less starts no probe, even on a store that would earn a note.</summary>
+    [Fact]
+    public async Task AShortWindow_StartsNoProbe_AndShowsNoNote()
+    {
+        await _duckDb.InitializeAsync();
+        var probes = 0;
+
+        var (visible, _) = await NoteAsync(End.AddMinutes(-90), End, [], [], relation => { probes++; return Task.FromResult<DateTime?>(End); });
+
+        Assert.False(visible);
+        Assert.Equal(0, probes);
+    }
+
+    private static T OnStaThread<T>(Func<T> body)
+    {
+        T result = default!;
+        Exception? error = null;
+        var thread = new Thread(() =>
+        {
+            try { result = body(); }
+            catch (Exception ex) { error = ex; }
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (error is not null)
+        {
+            throw error;
+        }
+
+        return result;
+    }
+}
diff --git a/Lite.Tests/OverviewBlockingLaneDataStartPinTests.cs b/Lite.Tests/OverviewBlockingLaneDataStartPinTests.cs
new file mode 100644
index 0000000000..52896feaff
--- /dev/null
+++ b/Lite.Tests/OverviewBlockingLaneDataStartPinTests.cs
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Lite.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using Xunit;
+
+namespace PerformanceMonitorLite.Tests;
+
+/// <summary>
+/// How the Overview's blocking chart is wired to say where its data starts (#4966), read from the source because the control needs a
+/// window to run. The choice is in <c>OverviewBlockingLaneDataStartTests</c>, the notice in <c>OverviewBlockingLaneDataStartLiveTests</c>.
+/// </summary>
+public sealed class OverviewBlockingLaneDataStartPinTests
+{
+    private static string Code() => Read("CorrelatedTimelineLanesControl.xaml.cs");
+
+    private static string Xaml() => Read("CorrelatedTimelineLanesControl.xaml");
+
+    private static string Step() => Read("LiteBlockingLaneDataStart.cs");
+
+    private static string Between(string source, string from, string to)
+    {
+        var start = source.IndexOf(from, StringComparison.Ordinal);
+        Assert.True(start >= 0, from + " was not found");
+        var end = source.IndexOf(to, start, StringComparison.Ordinal);
+        Assert.True(end > start, to + " was not found after " + from);
+        return source[start..end];
+    }
+
+    [Fact]
+    public void RefreshAsync_RunsTheNoteAfterTheLanesAreDrawn_OutsideTheReadsWhenAll()
+    {
+        var refresh = Between(Code(), "public async Task RefreshAsync(", "private async Task ShowBlockingLaneDataStartAsync(");
+
+        var whenAll = Between(refresh, "await Task.WhenAll(", ");");
+        Assert.DoesNotContain("DataStart", whenAll, StringComparison.Ordinal);
+
+        var drawn = refresh.IndexOf("UpdateBlockingLane(blockingData", StringComparison.Ordinal);
+        var ghost = refresh.IndexOf("AddGhostLine(BlockingChart", StringComparison.Ordinal);
+        var axes = refresh.IndexOf("SyncXAxes(hoursBack", StringComparison.Ordinal);
+        var note = refresh.IndexOf("await ShowBlockingLaneDataStartAsync(", StringComparison.Ordinal);
+        Assert.True(drawn > 0 && ghost > drawn && axes > ghost && note > axes, "the lanes, ghost lines and axes come before the note");
+        Assert.Single(Regex.Matches(refresh, "ShowBlockingLaneDataStartAsync"));
+    }
+
+    [Fact]
+    public void TheWindow_IsTheOneTheReadsTake_AndTheNoteIsFedFromBothSeriesBars()
+    {
+        var refresh = Between(Code(), "public async Task RefreshAsync(", "private async Task ShowBlockingLaneDataStartAsync(");
+        Assert.Contains("var (windowStartUtc, windowEndUtc) = LocalDataService.GetTimeRange(hoursBack, fromDate, toDate, asOfUtc: null);", refresh, StringComparison.Ordinal);
+        Assert.Contains("GetBlockingTrendAsync(_serverId, hoursBack, fromDate, toDate)", refresh, StringComparison.Ordinal);
+        Assert.Contains("GetDeadlockTrendAsync(_serverId, hoursBack, fromDate, toDate)", refresh, StringComparison.Ordinal);
+
+        var call = Between(refresh, "await ShowBlockingLaneDataStartAsync(", ");");
+        Assert.Contains("windowStartUtc, windowEndUtc", call, StringComparison.Ordinal);
+        Assert.Contains("blockingTask.Result", call, StringComparison.Ordinal);
+        Assert.Contains("deadlockTask.Result", call, StringComparison.Ordinal);
+
+        var wrapper = Between(Code(), "private async Task ShowBlockingLaneDataStartAsync(", "private void UpdateBlockingLane(");
+        Assert.Contains("LiteBlockingLaneDataStart.ShowAsync(", wrapper, StringComparison.Ordinal);
+        Assert.Contains("BlockingLaneDataStartBanner", wrapper, StringComparison.Ordinal);
+        Assert.Contains("GetQueryWindowFloorAsync(relation, _serverId, startUtc, endUtc)", wrapper, StringComparison.Ordinal);
+        Assert.Contains("_displayZone()", wrapper, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TheStep_ProbesBothRelations_ThroughTheShortWindowGuard_AndWordsTheBanner()
+    {
+        var step = Between(Step(), "internal static async Task ShowAsync(", "/// <summary>One series' start:");
+        Assert.DoesNotContain("ProbeWindowFloorOrNullAsync", step, StringComparison.Ordinal);
+        Assert.True(step.IndexOf("McpQueryTools.CanWindowBeTruncated(startUtc, endUtc)", StringComparison.Ordinal)
+            < step.IndexOf("Probe(floorOf, QueryWindowRelation.BlockedProcessReports)", StringComparison.Ordinal));
+        Assert.Contains("Probe(floorOf, QueryWindowRelation.Deadlocks)", step, StringComparison.Ordinal);
+        Assert.Contains("StartAsync(floorOf, startUtc, endUtc, blockingBars, deadlockBars)", step, StringComparison.Ordinal);
+        Assert.Contains("ChooseAsync(blockingProbe, deadlockProbe, blockingBars, deadlockBars)", step, StringComparison.Ordinal);
+        Assert.Contains("ServerTab.ApplyWindowFloorToBanner(banner, start, startUtc, zone)", step, StringComparison.Ordinal);
+        Assert.Contains("bar.Count > 0", Step(), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TheBanner_IsDeclaredInAnAutoRowAboveTheChart_AndOnlyOnTheBlockingLane()
+    {
+        var chart = Between(Xaml(), "<!-- Lane 3: Blocking -->", "<!-- Lane 4");
+        Assert.Contains("<RowDefinition Height=\"Auto\"/>", chart, StringComparison.Ordinal);
+        Assert.Matches(@"x:Name=""BlockingLaneDataStartBanner""\s+Visibility=""Collapsed""", chart);
+        Assert.Contains("Foreground=\"{DynamicResource ForegroundBrush}\"", chart, StringComparison.Ordinal);
+        Assert.Contains("<ScottPlot:WpfPlot Grid.Row=\"1\" Grid.Column=\"1\" x:Name=\"BlockingChart\"/>", chart, StringComparison.Ordinal);
+        Assert.Single(Regex.Matches(Xaml(), "DataStartBanner"));
+    }
+
+    private static string Read(string name, [CallerFilePath] string thisFile = "") =>
+        File.ReadAllText(Path.GetFullPath(Path.Combine(Path.GetDirectoryName(thisFile)!, "..", "Lite", "Controls", name))).ReplaceLineEndings("\n");
+}
diff --git a/Lite.Tests/OverviewBlockingLaneDataStartTests.cs b/Lite.Tests/OverviewBlockingLaneDataStartTests.cs
new file mode 100644
index 0000000000..6afcda6812
--- /dev/null
+++ b/Lite.Tests/OverviewBlockingLaneDataStartTests.cs
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Lite.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using PerformanceMonitorLite.Controls;
+using PerformanceMonitorLite.Services;
+using Xunit;
+
+namespace PerformanceMonitorLite.Tests;
+
+/// <summary>
+/// What the Overview's blocking chart names as its data start (#4966): the later of its two series' starts, each the earlier of the
+/// series' coverage floor and its earliest bar drawn. Pure logic, no store and no WPF object.
+/// </summary>
+public sealed class OverviewBlockingLaneDataStartTests
+{
+    private static readonly DateTime Day = new(2026, 9, 10, 0, 0, 0, DateTimeKind.Unspecified);
+
+    private static Task<DateTime?> Answer(DateTime? start) => Task.FromResult(start);
+
+    private static readonly TrendPoint[] NoBars = [];
+
+    private static TrendPoint Bar(DateTime at, int count = 1) => new() { Time = at, Count = count };
+
+    [Fact]
+    public async Task TwoStarts_NameTheLaterOne_WhicheverSeriesHasIt()
+    {
+        Assert.Equal(Day.AddDays(2), await LiteBlockingLaneDataStart.ChooseAsync(Answer(Day.AddDays(2)), Answer(Day), NoBars, NoBars));
+        Assert.Equal(Day.AddDays(2), await LiteBlockingLaneDataStart.ChooseAsync(Answer(Day), Answer(Day.AddDays(2)), NoBars, NoBars));
+    }
+
+    [Fact]
+    public async Task OneSeriesOnly_IsNamed_AndNeitherNamesNothing()
+    {
+        Assert.Equal(Day.AddDays(1), await LiteBlockingLaneDataStart.ChooseAsync(Answer(Day.AddDays(1)), Answer(null), NoBars, NoBars));
+        Assert.Equal(Day.AddDays(1), await LiteBlockingLaneDataStart.ChooseAsync(Answer(null), Answer(Day.AddDays(1)), NoBars, NoBars));
+        Assert.Null(await LiteBlockingLaneDataStart.ChooseAsync(Answer(null), Answer(null), NoBars, NoBars));
+    }
+
+    [Fact]
+    public async Task ABarBeforeTheFloor_MovesThatSeriesStartBack_AndNoFloorLetsTheBarName()
+    {
+        Assert.Equal(Day.AddDays(2), await LiteBlockingLaneDataStart.ChooseAsync(
+            Answer(Day.AddDays(2)), Answer(Day.AddDays(3)), NoBars, [Bar(Day.AddDays(1)), Bar(Day.AddDays(4))]));
+        Assert.Equal(Day.AddDays(1), await LiteBlockingLaneDataStart.ChooseAsync(
+            Answer(null), Answer(Day.AddDays(3)), [Bar(Day.AddDays(1))], [Bar(Day.AddDays(1))]));
+        Assert.Equal(Day.AddHours(5), await LiteBlockingLaneDataStart.ChooseAsync(Answer(null), Answer(null), [Bar(Day.AddHours(5)), Bar(Day.AddHours(9))], NoBars));
+    }
+
+    [Fact]
+    public async Task AZeroBucket_IsNotABar()
+    {
+        Assert.Equal(Day.AddDays(2), await LiteBlockingLaneDataStart.ChooseAsync(
+            Answer(Day.AddDays(2)), Answer(Day.AddDays(2)), [Bar(Day, 0), Bar(Day.AddDays(1), 0)], NoBars));
+        Assert.Null(await LiteBlockingLaneDataStart.ChooseAsync(Answer(null), Answer(null), [Bar(Day, 0)], [Bar(Day, 0)]));
+        Assert.Equal(Day.AddHours(7), LiteBlockingLaneDataStart.SeriesStart(null, [Bar(Day, 0), Bar(Day.AddHours(7)), Bar(Day.AddHours(9))]));
+    }
+
+    [Fact]
+    public async Task AProbeThatThrows_DropsItsSeries_AndNeverThrowsOut()
+    {
+        var failed = Task.FromException<DateTime?>(new InvalidOperationException("the store went away"));
+        Assert.Equal(Day.AddDays(2), await LiteBlockingLaneDataStart.ChooseAsync(failed, Answer(Day.AddDays(2)), NoBars, NoBars));
+        Assert.Null(await LiteBlockingLaneDataStart.ChooseAsync(failed, Task.FromException<DateTime?>(new TimeoutException()), [Bar(Day)], [Bar(Day)]));
+        Assert.Null(await LiteBlockingLaneDataStart.ChooseAsync(failed, Task.FromException<DateTime?>(new TimeoutException()), NoBars, NoBars));
+    }
+
+    /// <summary>A failed blocking probe gives no start even with a late bar; the deadlock series answers alone, so its start (the window start) is named.</summary>
+    [Fact]
+    public async Task AFailedProbe_WithALateBar_DoesNotRaiseTheNote()
+    {
+        var failed = Task.FromException<DateTime?>(new InvalidOperationException("the store went away"));
+        var result = await LiteBlockingLaneDataStart.ChooseAsync(failed, Answer(Day), [Bar(Day.AddDays(5))], NoBars);
+        Assert.Equal(Day, result);
+    }
+
+    /// <summary>The probing half of the step: both relations are asked over the window given, and the later floor wins.</summary>
+    [Fact]
+    public async Task StartAsync_AsksBothRelations_AndNamesTheLaterFloor()
+    {
+        var asked = new List<QueryWindowRelation>();
+        var start = await LiteBlockingLaneDataStart.StartAsync(
+            relation => { asked.Add(relation); return Task.FromResult<DateTime?>(relation == QueryWindowRelation.Deadlocks ? Day.AddDays(3) : Day.AddDays(1)); },
+            Day, Day.AddDays(7), NoBars, NoBars);
+
+        Assert.Equal(Day.AddDays(3), start);
+        Assert.Contains(QueryWindowRelation.BlockedProcessReports, asked);
+        Assert.Contains(QueryWindowRelation.Deadlocks, asked);
+    }
+
+    /// <summary>A window of 90 minutes or less calls neither probe.</summary>
+    [Fact]
+    public async Task StartAsync_ShortWindow_CallsNeitherProbe()
+    {
+        var calls = 0;
+        Assert.Null(await LiteBlockingLaneDataStart.StartAsync(_ => { calls++; return Task.FromResult<DateTime?>(Day); }, Day, Day.AddMinutes(90), [Bar(Day)], [Bar(Day)]));
+        Assert.Equal(0, calls);
+    }
+
+    /// <summary>A window of 90 minutes or less starts no probe, and a probe that throws drops only its series.</summary>
+    [Fact]
+    public async Task StartAsync_ShortWindowStartsNoProbe_AndAThrowingProbeDropsOneSeries()
+    {
+        var probes = 0;
+        Assert.Null(await LiteBlockingLaneDataStart.StartAsync(_ => { probes++; return Task.FromResult<DateTime?>(Day); }, Day, Day.AddMinutes(90), NoBars, NoBars));
+        Assert.Equal(0, probes);
+
+        Assert.Equal(Day.AddDays(2), await LiteBlockingLaneDataStart.StartAsync(
+            relation => relation == QueryWindowRelation.Deadlocks ? Task.FromResult<DateTime?>(Day.AddDays(2)) : throw new InvalidOperationException("probe failed"),
+            Day, Day.AddDays(7), NoBars, NoBars));
+    }
+}
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml b/Lite/Controls/CorrelatedTimelineLanesControl.xaml
index f0f18715e9..7f571d4648 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml
@@ -43,14 +43,23 @@
                 <ColumnDefinition Width="100"/>
                 <ColumnDefinition Width="*"/>
             </Grid.ColumnDefinitions>
-            <TextBlock Grid.Column="0" VerticalAlignment="Center"
+            <Grid.RowDefinitions>
+                <!-- The "Showing since" note: Auto, so a hidden note gives the whole chart back to the chart. -->
+                <RowDefinition Height="Auto"/>
+                <RowDefinition Height="*"/>
+            </Grid.RowDefinitions>
+            <TextBlock Grid.Row="0" Grid.Column="1" x:Name="BlockingLaneDataStartBanner" Visibility="Collapsed"
+                       Padding="8,1" FontSize="11" FontWeight="Bold"
+                       Foreground="{DynamicResource ForegroundBrush}"
+                       Background="#22FFAA00"/>
+            <TextBlock Grid.Row="0" Grid.RowSpan="2" Grid.Column="0" VerticalAlignment="Center"
                        FontSize="12" FontWeight="SemiBold"
                        Foreground="{DynamicResource ForegroundBrush}" Margin="4,0">
                 <Run Text="Blocking &amp;"/>
                 <LineBreak/>
                 <Run Text="Deadlocking"/>
             </TextBlock>
-            <ScottPlot:WpfPlot Grid.Column="1" x:Name="BlockingChart"/>
+            <ScottPlot:WpfPlot Grid.Row="1" Grid.Column="1" x:Name="BlockingChart"/>
         </Grid>
 
         <!-- Lane 4: Buffer Pool -->
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index a65d08e2fd..2d1b797c67 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -196,6 +196,9 @@ public async Task RefreshAsync(int hoursBack, DateTime? fromDate, DateTime? toDa
         {
             _crosshairManager?.PrepareForRefresh();
 
+            /* #4966: the UTC window the blocking and deadlock reads below take (their own GetTimeRange call), for the data-start note. */
+            var (windowStartUtc, windowEndUtc) = LocalDataService.GetTimeRange(hoursBack, fromDate, toDate, asOfUtc: null);
+
             var cpuTask = Task.Run(() => _dataService.GetCpuUtilizationAsync(_serverId, hoursBack, fromDate, toDate, frame: CpuTimeFrame.Utc));
             var waitTask = Task.Run(() => _dataService.GetTotalWaitTrendAsync(_serverId, hoursBack, fromDate, toDate));
             var blockingTask = Task.Run(() => _dataService.GetBlockingTrendAsync(_serverId, hoursBack, fromDate, toDate));
@@ -346,6 +349,14 @@ Each ghost row goes back onto the current axis by the same rule in reverse (Time
                the render set when the chart refreshes. */
             _crosshairManager?.ReattachVLines();
             SyncXAxes(hoursBack, fromDate, toDate);
+
+            /* #4966: the blocking chart draws event counts, so an empty stretch reads as "nothing happened" and the chart says
+               where its data starts. The note comes last, after every lane and the ghost lines are drawn and synced, and on its
+               own: the probes are not part of the reads' WhenAll above, and a probe that fails costs the note, never the bars. */
+            await ShowBlockingLaneDataStartAsync(
+                windowStartUtc, windowEndUtc,
+                blockingTask.IsCompletedSuccessfully ? blockingTask.Result : [],
+                deadlockTask.IsCompletedSuccessfully ? deadlockTask.Result : []);
         }
         finally
         {
@@ -357,6 +368,21 @@ the render set when the chart refreshes. */
         }
     }
 
+    /// <summary>
+    /// Raises or hides the blocking chart's "Showing since" note (#4966). The chart's two series, blocking and deadlocks, are
+    /// event counts: an empty stretch before a series starts reads as "nothing happened". A window of 90 minutes or less
+    /// starts no probe (<see cref="ServerTab.ProbeWindowFloorOrNullAsync"/>). The text goes through the shared banner step in
+    /// the lanes' own clock (<c>_displayZone</c>, which is the tab's <c>GetPickerZone</c>), to the second.
+    /// </summary>
+    private async Task ShowBlockingLaneDataStartAsync(
+        DateTime startUtc, DateTime endUtc, IReadOnlyList<TrendPoint> blockingBars, IReadOnlyList<TrendPoint> deadlockBars)
+    {
+        await LiteBlockingLaneDataStart.ShowAsync(
+            BlockingLaneDataStartBanner,
+            relation => Task.Run(() => _dataService!.GetQueryWindowFloorAsync(relation, _serverId, startUtc, endUtc)),
+            startUtc, endUtc, blockingBars, deadlockBars, _displayZone());
+    }
+
     private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
         List<(double Time, double Value)> deadlockData, BaselineBucket? baseline = null)
     {
diff --git a/Lite/Controls/LiteBlockingLaneDataStart.cs b/Lite/Controls/LiteBlockingLaneDataStart.cs
new file mode 100644
index 0000000000..e03974dc82
--- /dev/null
+++ b/Lite/Controls/LiteBlockingLaneDataStart.cs
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor Lite.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+using PerformanceMonitorLite.Mcp;
+using PerformanceMonitorLite.Services;
+
+namespace PerformanceMonitorLite.Controls;
+
+/// <summary>
+/// Where the Overview's blocking chart says its data starts (#4966). The chart draws two event-count series, blocking and
+/// deadlocks, so an empty stretch before a series starts reads as "nothing happened". Each series starts at the EARLIER of its
+/// coverage floor and its earliest bar drawn (a zero bucket is not a bar); the chart has one note, and it names the LATER of
+/// the two starts so it is true of both series. A series with no start (no floor, no bar, or a probe that failed with no bar)
+/// is left out; when neither has one the chart shows no note. The Darling viewer's twin is <c>ViewerBlockingLaneDataStart</c>.
+/// <para>Two rules: a probe that FAILED gives its series no start, whatever its bars (a failure is not evidence of a late start, so
+/// the other series answers alone); a probe that ANSWERED null (no collector run in the window) with bars drawn names the first
+/// bar, as the viewer does (<c>ViewerEventDataStart.Of</c>). Lite's own Blocking tab differs: it keeps the null there
+/// (<c>EarlierOfFloorAndRowShown</c>).</para>
+/// </summary>
+internal static class LiteBlockingLaneDataStart
+{
+    /// <summary>
+    /// The instant the chart's note names, or null when it names nothing. A probe that throws costs its series' start and
+    /// nothing else: it is logged and the other series answers alone.
+    /// </summary>
+    internal static async Task<DateTime?> ChooseAsync(
+        Task<DateTime?> blockingProbe, Task<DateTime?> deadlockProbe,
+        IEnumerable<TrendPoint> blockingBars, IEnumerable<TrendPoint> deadlockBars)
+    {
+        ArgumentNullException.ThrowIfNull(blockingProbe);
+        ArgumentNullException.ThrowIfNull(deadlockProbe);
+        ArgumentNullException.ThrowIfNull(blockingBars);
+        ArgumentNullException.ThrowIfNull(deadlockBars);
+
+        var blocking = await AnswerAsync(blockingProbe, "blocking");
+        var deadlock = await AnswerAsync(deadlockProbe, "deadlocks");
+
+        return Later(
+            blocking.Failed ? null : SeriesStart(blocking.Floor, blockingBars),
+            deadlock.Failed ? null : SeriesStart(deadlock.Floor, deadlockBars));
+    }
+
+    /// <summary>
+    /// The note step: chooses the start the note names, then words the banner in <paramref name="zone"/>
+    /// (<see cref="ServerTab.ApplyWindowFloorToBanner"/>). The banner is touched on the caller's thread only, after the start is chosen.
+    /// </summary>
+    internal static async Task ShowAsync(
+        TextBlock banner, Func<QueryWindowRelation, Task<DateTime?>> floorOf, DateTime startUtc, DateTime endUtc,
+        IEnumerable<TrendPoint> blockingBars, IEnumerable<TrendPoint> deadlockBars, TimeZoneInfo zone)
+    {
+        var start = await StartAsync(floorOf, startUtc, endUtc, blockingBars, deadlockBars);
+        ServerTab.ApplyWindowFloorToBanner(banner, start, startUtc, zone);
+    }
+
+    /// <summary>
+    /// Probes BOTH relations over the window the chart's reads took (a window of 90 minutes or less starts no probe, and a probe
+    /// that throws costs only its series' start) and chooses the start. <paramref name="floorOf"/> is
+    /// <c>LocalDataService.GetQueryWindowFloorAsync</c> for the relation. Touches no WPF object, so the live-store tests drive it.
+    /// </summary>
+    internal static async Task<DateTime?> StartAsync(
+        Func<QueryWindowRelation, Task<DateTime?>> floorOf, DateTime startUtc, DateTime endUtc,
+        IEnumerable<TrendPoint> blockingBars, IEnumerable<TrendPoint> deadlockBars)
+    {
+        if (!McpQueryTools.CanWindowBeTruncated(startUtc, endUtc))
+        {
+            return null;
+        }
+
+        /* The shared floor-or-null wrapper is not used here: it turns a throw into null, and null here would read as "no collector run". */
+        var blockingProbe = Probe(floorOf, QueryWindowRelation.BlockedProcessReports);
+        var deadlockProbe = Probe(floorOf, QueryWindowRelation.Deadlocks);
+
+        return await ChooseAsync(blockingProbe, deadlockProbe, blockingBars, deadlockBars);
+    }
+
+    /// <summary>One series' start: the earlier of its floor and its earliest bar with a count above zero; whichever exists; null when neither.</summary>
+    internal static DateTime? SeriesStart(DateTime? floor, IEnumerable<TrendPoint> bars)
+    {
+        DateTime? firstBar = null;
+        foreach (var bar in bars)
+        {
+            if (bar.Count > 0 && (firstBar is null || bar.Time < firstBar.Value))
+            {
+                firstBar = bar.Time;
+            }
+        }
+
+        return floor is DateTime f && firstBar is DateTime b ? (b < f ? b : f) : floor ?? firstBar;
+    }
+
+    /// <summary>The later of two series' starts; the one that answered when only one did; null when neither did.</summary>
+    internal static DateTime? Later(DateTime? blocking, DateTime? deadlock) =>
+        blocking.HasValue && deadlock.HasValue ? (blocking.Value >= deadlock.Value ? blocking : deadlock) : blocking ?? deadlock;
+
+    private static Task<DateTime?> Probe(Func<QueryWindowRelation, Task<DateTime?>> floorOf, QueryWindowRelation relation)
+    {
+        try
+        {
+            return floorOf(relation);
+        }
+        catch (Exception ex)
+        {
+            return Task.FromException<DateTime?>(ex);
+        }
+    }
+
+    private static async Task<(bool Failed, DateTime? Floor)> AnswerAsync(Task<DateTime?> probe, string series)
+    {
+        try
+        {
+            return (false, await probe);
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Warn("CorrelatedLanes", $"Overview blocking chart ({series}): the data-start probe failed, so that series names no start: {ex.Message}");
+            return (true, null);
+        }
+    }
+}