From f7de985dbacc2b3987fc6f142dfbfcd80468b3f9 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:00:58 -0400
Subject: [PATCH 01/33] Time range model: presets, calendar periods,
 typed-range parser and shared fixture (#5562)

---
 Darling/Darling.Tests/Darling.Tests.csproj    |    2 +
 .../Fixtures/time-range-cases.json            | 1113 +++++++++++++++++
 Darling/Darling.Tests/TimeRangeTests.cs       |  284 +++++
 Lite.Tests/Lite.Tests.csproj                  |    3 +
 .../TimeRange/ResolvedTimeRange.cs            |  109 ++
 .../TimeRange/TimeRangeParser.cs              |  617 +++++++++
 .../TimeRange/TimeRangePresets.cs             |  159 +++
 .../TimeRange/TimeRangeSpec.cs                |  461 +++++++
 8 files changed, 2748 insertions(+)
 create mode 100644 Darling/Darling.Tests/Fixtures/time-range-cases.json
 create mode 100644 Darling/Darling.Tests/TimeRangeTests.cs
 create mode 100644 PerformanceMonitor.Ui/TimeRange/ResolvedTimeRange.cs
 create mode 100644 PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs
 create mode 100644 PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
 create mode 100644 PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs

diff --git a/Darling/Darling.Tests/Darling.Tests.csproj b/Darling/Darling.Tests/Darling.Tests.csproj
index 3612ad7360..f897f59612 100644
--- a/Darling/Darling.Tests/Darling.Tests.csproj
+++ b/Darling/Darling.Tests/Darling.Tests.csproj
@@ -50,6 +50,8 @@
   <ItemGroup>
     <!-- system_health event samples for SystemHealthParser (one per feeder event; shapes per sp_HealthParser xpath). -->
     <None Include="Fixtures\FinOpsIndexAnalysis\golden.json" CopyToOutputDirectory="PreserveNewest" />
+    <!-- The shared time range grammar cases (#5562); the web harness reads the same file. -->
+    <None Include="Fixtures\time-range-cases.json" CopyToOutputDirectory="PreserveNewest" />
     <None Include="Fixtures\SystemHealth\*.xml" CopyToOutputDirectory="PreserveNewest" />
     <!-- real, scrubbed system_health event captures for SystemHealthParserRealEventTests -->
     <None Include="Fixtures\SystemHealth\real\*.xml" CopyToOutputDirectory="PreserveNewest" />
diff --git a/Darling/Darling.Tests/Fixtures/time-range-cases.json b/Darling/Darling.Tests/Fixtures/time-range-cases.json
new file mode 100644
index 0000000000..1b51a1e519
--- /dev/null
+++ b/Darling/Darling.Tests/Fixtures/time-range-cases.json
@@ -0,0 +1,1113 @@
+{
+ "_doc": [
+  "Shared cases for the time range grammar (#5562). The C# parser (PerformanceMonitor.Ui TimeRangeParser) and the web module (time-range.js) must both produce every row here.",
+  "Zone ids are IANA names (America/New_York, UTC, Asia/Kolkata, Australia/Sydney): .NET resolves them through ICU and Node through Intl. Do not use Windows ids.",
+  "All instants are ISO 8601 UTC with a trailing Z. 'now' is the clock the case is resolved at; nothing reads the machine's clock.",
+  "'start' and 'end' are the resolved instants (end is now for a live range). 'live' is true when the end slides with now. 'echo' is the exact label text the picker shows. 'error' is a stable code; the message text is not compared.",
+  "Typed wall times use the earliest instant for a start and the latest for an end (a repeated hour widens; a skipped time maps to the change instant). Nm/Nh/Nd are real elapsed time. Calendar periods use wall-clock midnights in the zone and weeks start Monday. 1mo is 30 real days.",
+  "Echo format: '<length>  <start> - <end> (<zone>)'. Length is Nd (floored) for a day or more, else 'Hh Mm' with zero parts dropped. A bound is 'Mon D, h:mm am|pm' (English month abbreviations, lower-case am/pm), with ', YYYY' after the day when either end is not in now's year, ':ss' for typed/unix ranges when the seconds are not zero, and ' +hh:mm' appended to a bound whose wall time happens twice. Zone is 'UTC-04:00' or 'UTC-05:00 to UTC-04:00' when the ends differ."
+ ],
+ "minimumSpanMinutes": 5,
+ "cases": [
+  {
+   "name": "relative 45m",
+   "input": "45m",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T10:16:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "45m  Oct 8, 6:16 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative 12 hours",
+   "input": "12 hours",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-07T23:01:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "12h  Oct 7, 7:01 pm - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative 10d",
+   "input": "10d",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-09-28T11:01:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "10d  Sep 28, 7:01 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative 2 weeks",
+   "input": "2 weeks",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-09-24T11:01:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "14d  Sep 24, 7:01 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative last 3 days",
+   "input": "last 3 days",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-05T11:01:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "3d  Oct 5, 7:01 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative past 90 min",
+   "input": "Past 90 Min",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T09:31:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "1h 30m  Oct 8, 5:31 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative 1.5 hours",
+   "input": "1.5 hours",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T09:31:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "1h 30m  Oct 8, 5:31 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative 1mo is 30 real days",
+   "input": "1mo",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-09-08T11:01:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "30d  Sep 8, 7:01 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative 1 month typed in full",
+   "input": "1 month",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-09-08T11:01:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "30d  Sep 8, 7:01 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative spaces and case",
+   "input": "   12   HOURS ",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-07T23:01:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "12h  Oct 7, 7:01 pm - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "relative 5m is the floor",
+   "input": "5m",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T10:56:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "5m  Oct 8, 6:56 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "last month",
+   "input": "last month",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-09-01T04:00:00Z",
+   "end": "2026-10-01T04:00:00Z",
+   "live": false,
+   "echo": "30d  Sep 1, 12:00 am - Oct 1, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "previous month typed out",
+   "input": "Previous Month",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-09-01T04:00:00Z",
+   "end": "2026-10-01T04:00:00Z",
+   "live": false,
+   "echo": "30d  Sep 1, 12:00 am - Oct 1, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "yesterday",
+   "input": "yesterday",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-07T04:00:00Z",
+   "end": "2026-10-08T04:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 7, 12:00 am - Oct 8, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "today",
+   "input": "today",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T04:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "7h 1m  Oct 8, 12:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "week to date starts Monday",
+   "input": "week to date",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-05T04:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "3d  Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "this week",
+   "input": "this week",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-05T04:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "3d  Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "last week",
+   "input": "last week",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-09-28T04:00:00Z",
+   "end": "2026-10-05T04:00:00Z",
+   "live": false,
+   "echo": "7d  Sep 28, 12:00 am - Oct 5, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "month to date",
+   "input": "mtd",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "7d  Oct 1, 12:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "year to date spans the winter offset",
+   "input": "year to date",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-01-01T05:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "280d  Jan 1, 12:00 am - Oct 8, 7:01 am (UTC-05:00 to UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "last year",
+   "input": "last year",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2025-01-01T05:00:00Z",
+   "end": "2026-01-01T05:00:00Z",
+   "live": false,
+   "echo": "365d  Jan 1, 2025, 12:00 am - Jan 1, 2026, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "sunday belongs to the week that began Monday",
+   "input": "this week",
+   "now": "2026-10-12T03:30:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-05T04:00:00Z",
+   "end": "2026-10-12T03:30:00Z",
+   "live": true,
+   "echo": "6d  Oct 5, 12:00 am - Oct 11, 11:30 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "monday morning: this week has only just begun",
+   "input": "this week",
+   "now": "2026-10-12T14:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-12T04:00:00Z",
+   "end": "2026-10-12T14:00:00Z",
+   "live": true,
+   "echo": "10h  Oct 12, 12:00 am - Oct 12, 10:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "one date is the whole day",
+   "input": "Oct 1",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-02T04:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 1, 12:00 am - Oct 2, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "one numeric date is the whole day",
+   "input": "10/1",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-02T04:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 1, 12:00 am - Oct 2, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "end date is included",
+   "input": "Oct 1 - Oct 2",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-03T04:00:00Z",
+   "live": false,
+   "echo": "2d  Oct 1, 12:00 am - Oct 3, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "numeric dates",
+   "input": "10/1 - 10/2",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-03T04:00:00Z",
+   "live": false,
+   "echo": "2d  Oct 1, 12:00 am - Oct 3, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "numeric dates with no spaces",
+   "input": "10/1-10/2",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-03T04:00:00Z",
+   "live": false,
+   "echo": "2d  Oct 1, 12:00 am - Oct 3, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "to and an en dash",
+   "input": "Oct 1 – Oct 2",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-03T04:00:00Z",
+   "live": false,
+   "echo": "2d  Oct 1, 12:00 am - Oct 3, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "to as a word",
+   "input": "october 1st to october 2nd",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-03T04:00:00Z",
+   "live": false,
+   "echo": "2d  Oct 1, 12:00 am - Oct 3, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "from ... to ...",
+   "input": "from 10/1 to 10/3",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-04T04:00:00Z",
+   "live": false,
+   "echo": "3d  Oct 1, 12:00 am - Oct 4, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "iso date alone",
+   "input": "2026-10-01",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-02T04:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 1, 12:00 am - Oct 2, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "iso date and time",
+   "input": "2026-10-01 13:00 - 2026-10-01 15:00",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T17:00:00Z",
+   "end": "2026-10-01T19:00:00Z",
+   "live": false,
+   "echo": "2h  Oct 1, 1:00 pm - Oct 1, 3:00 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "explicit years",
+   "input": "12/31/2025 - 1/2/26",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2025-12-31T05:00:00Z",
+   "end": "2026-01-03T05:00:00Z",
+   "live": false,
+   "echo": "3d  Dec 31, 2025, 12:00 am - Jan 3, 2026, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "day first",
+   "input": "1 Oct 2025",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2025-10-01T04:00:00Z",
+   "end": "2025-10-02T04:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 1, 2025, 12:00 am - Oct 2, 2025, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "a date with a time, same day end",
+   "input": "Oct 2 12pm - 3pm",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-02T16:00:00Z",
+   "end": "2026-10-02T19:00:00Z",
+   "live": false,
+   "echo": "3h  Oct 2, 12:00 pm - Oct 2, 3:00 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "date and time on both sides",
+   "input": "Oct 2 9:30 am to Oct 3 5:15 pm",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-02T13:30:00Z",
+   "end": "2026-10-03T21:15:00Z",
+   "live": false,
+   "echo": "1d  Oct 2, 9:30 am - Oct 3, 5:15 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "date only start, time end",
+   "input": "Oct 1 - 3pm",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-01T19:00:00Z",
+   "live": false,
+   "echo": "15h  Oct 1, 12:00 am - Oct 1, 3:00 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "date year from the latest not in the future (earlier this year)",
+   "input": "Oct 1",
+   "now": "2026-09-15T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2025-10-01T04:00:00Z",
+   "end": "2025-10-02T04:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 1, 2025, 12:00 am - Oct 2, 2025, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "same date today counts as not in the future",
+   "input": "Oct 8",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T04:00:00Z",
+   "end": "2026-10-09T04:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 8, 12:00 am - Oct 9, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "range across new year takes the year before",
+   "input": "Dec 30 - Jan 2",
+   "now": "2026-01-15T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2025-12-30T05:00:00Z",
+   "end": "2026-01-03T05:00:00Z",
+   "live": false,
+   "echo": "4d  Dec 30, 2025, 12:00 am - Jan 3, 2026, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "leap day goes back to the last leap year",
+   "input": "Feb 29",
+   "now": "2026-03-15T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2024-02-29T05:00:00Z",
+   "end": "2024-03-01T05:00:00Z",
+   "live": false,
+   "echo": "1d  Feb 29, 2024, 12:00 am - Mar 1, 2024, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "times only, today",
+   "input": "1:00 am - 7:00 am",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T05:00:00Z",
+   "end": "2026-10-08T11:00:00Z",
+   "live": false,
+   "echo": "6h  Oct 8, 1:00 am - Oct 8, 7:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "times only, 24 hour, not yet today so yesterday",
+   "input": "13:00 - 15:00",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-07T17:00:00Z",
+   "end": "2026-10-07T19:00:00Z",
+   "live": false,
+   "echo": "2h  Oct 7, 1:00 pm - Oct 7, 3:00 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "times only crossing midnight",
+   "input": "22:00 - 02:00",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T02:00:00Z",
+   "end": "2026-10-08T06:00:00Z",
+   "live": false,
+   "echo": "4h  Oct 7, 10:00 pm - Oct 8, 2:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "noon to midnight",
+   "input": "noon - midnight",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-07T16:00:00Z",
+   "end": "2026-10-08T04:00:00Z",
+   "live": false,
+   "echo": "12h  Oct 7, 12:00 pm - Oct 8, 12:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "12 hour edge cases",
+   "input": "12am - 12pm",
+   "now": "2026-10-08T18:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T04:00:00Z",
+   "end": "2026-10-08T16:00:00Z",
+   "live": false,
+   "echo": "12h  Oct 8, 12:00 am - Oct 8, 12:00 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "time start, dated end",
+   "input": "9am - Oct 7 5pm",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-07T13:00:00Z",
+   "end": "2026-10-07T21:00:00Z",
+   "live": false,
+   "echo": "8h  Oct 7, 9:00 am - Oct 7, 5:00 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "since a date",
+   "input": "since 10/1",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "7d  Oct 1, 12:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "since a date and time",
+   "input": "since Oct 2 12pm",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-02T16:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "5d  Oct 2, 12:00 pm - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "to now",
+   "input": "Oct 2 12pm to now",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-02T16:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "5d  Oct 2, 12:00 pm - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "dash now",
+   "input": "10/1 - now",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "7d  Oct 1, 12:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "since a time is the latest such time",
+   "input": "since 9am",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-07T13:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "22h 1m  Oct 7, 9:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "since a time already passed today",
+   "input": "since 5:00",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-08T09:00:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "2h 1m  Oct 8, 5:00 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "unix seconds",
+   "input": "1790852543 - 1791457343",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T11:02:23Z",
+   "end": "2026-10-08T11:02:23Z",
+   "live": false,
+   "echo": "7d  Oct 1, 7:02:23 am - Oct 8, 7:02:23 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "unix milliseconds",
+   "input": "1790852543000 - 1791457343000",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T11:02:23Z",
+   "end": "2026-10-08T11:02:23Z",
+   "live": false,
+   "echo": "7d  Oct 1, 7:02:23 am - Oct 8, 7:02:23 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "unix since",
+   "input": "since 1790852543",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T11:02:23Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "6d  Oct 1, 7:02 am - Oct 8, 7:01 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "UTC yesterday",
+   "input": "yesterday",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "UTC",
+   "start": "2026-10-07T00:00:00Z",
+   "end": "2026-10-08T00:00:00Z",
+   "live": false,
+   "echo": "1d  Oct 7, 12:00 am - Oct 8, 12:00 am (UTC+00:00)",
+   "error": null
+  },
+  {
+   "name": "UTC typed times",
+   "input": "1:00 am - 7:00 am",
+   "now": "2026-10-08T07:30:00Z",
+   "zone": "UTC",
+   "start": "2026-10-08T01:00:00Z",
+   "end": "2026-10-08T07:00:00Z",
+   "live": false,
+   "echo": "6h  Oct 8, 1:00 am - Oct 8, 7:00 am (UTC+00:00)",
+   "error": null
+  },
+  {
+   "name": "India half-hour zone, today",
+   "input": "today",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "Asia/Kolkata",
+   "start": "2026-10-07T18:30:00Z",
+   "end": "2026-10-08T11:01:00Z",
+   "live": true,
+   "echo": "16h 31m  Oct 8, 12:00 am - Oct 8, 4:31 pm (UTC+05:30)",
+   "error": null
+  },
+  {
+   "name": "India typed times",
+   "input": "13:00 - 15:00",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "Asia/Kolkata",
+   "start": "2026-10-08T07:30:00Z",
+   "end": "2026-10-08T09:30:00Z",
+   "live": false,
+   "echo": "2h  Oct 8, 1:00 pm - Oct 8, 3:00 pm (UTC+05:30)",
+   "error": null
+  },
+  {
+   "name": "Sydney last month (southern summer time)",
+   "input": "last month",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "Australia/Sydney",
+   "start": "2026-08-31T14:00:00Z",
+   "end": "2026-09-30T14:00:00Z",
+   "live": false,
+   "echo": "30d  Sep 1, 12:00 am - Oct 1, 12:00 am (UTC+10:00)",
+   "error": null
+  },
+  {
+   "name": "spring: the short day is 23 hours",
+   "input": "Mar 8",
+   "now": "2026-03-09T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-03-08T05:00:00Z",
+   "end": "2026-03-09T04:00:00Z",
+   "live": false,
+   "echo": "23h  Mar 8, 12:00 am - Mar 9, 12:00 am (UTC-05:00 to UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "spring: yesterday is 23 hours",
+   "input": "yesterday",
+   "now": "2026-03-09T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-03-08T05:00:00Z",
+   "end": "2026-03-09T04:00:00Z",
+   "live": false,
+   "echo": "23h  Mar 8, 12:00 am - Mar 9, 12:00 am (UTC-05:00 to UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "spring: 1d is 24 real hours",
+   "input": "1d",
+   "now": "2026-03-09T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-03-08T16:00:00Z",
+   "end": "2026-03-09T16:00:00Z",
+   "live": true,
+   "echo": "1d  Mar 8, 12:00 pm - Mar 9, 12:00 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "spring: last week ends at Monday midnight",
+   "input": "last week",
+   "now": "2026-03-09T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-03-02T05:00:00Z",
+   "end": "2026-03-09T04:00:00Z",
+   "live": false,
+   "echo": "6d  Mar 2, 12:00 am - Mar 9, 12:00 am (UTC-05:00 to UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "spring: a skipped start maps to the change instant",
+   "input": "Mar 8 2:30 am - Mar 8 4:00 am",
+   "now": "2026-03-09T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-03-08T07:00:00Z",
+   "end": "2026-03-08T08:00:00Z",
+   "live": false,
+   "echo": "1h  Mar 8, 3:00 am - Mar 8, 4:00 am (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "spring: times across the change",
+   "input": "Mar 8 1:00 am - Mar 8 4:00 am",
+   "now": "2026-03-09T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-03-08T06:00:00Z",
+   "end": "2026-03-08T08:00:00Z",
+   "live": false,
+   "echo": "2h  Mar 8, 1:00 am - Mar 8, 4:00 am (UTC-05:00 to UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "fall: the long day is 25 hours",
+   "input": "Nov 1",
+   "now": "2026-11-02T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-11-01T04:00:00Z",
+   "end": "2026-11-02T05:00:00Z",
+   "live": false,
+   "echo": "1d  Nov 1, 12:00 am - Nov 2, 12:00 am (UTC-04:00 to UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "fall: yesterday is 25 hours",
+   "input": "yesterday",
+   "now": "2026-11-02T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-11-01T04:00:00Z",
+   "end": "2026-11-02T05:00:00Z",
+   "live": false,
+   "echo": "1d  Nov 1, 12:00 am - Nov 2, 12:00 am (UTC-04:00 to UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "fall: a repeated hour widens both ends",
+   "input": "Nov 1 1:00 am - Nov 1 1:45 am",
+   "now": "2026-11-02T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-11-01T05:00:00Z",
+   "end": "2026-11-01T06:45:00Z",
+   "live": false,
+   "echo": "1h 45m  Nov 1, 1:00 am -04:00 - Nov 1, 1:45 am -05:00 (UTC-04:00 to UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "fall: a repeated start with a plain end",
+   "input": "1:30 am - 3:00 am",
+   "now": "2026-11-01T18:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-11-01T05:30:00Z",
+   "end": "2026-11-01T08:00:00Z",
+   "live": false,
+   "echo": "2h 30m  Nov 1, 1:30 am -04:00 - Nov 1, 3:00 am (UTC-04:00 to UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "fall: times only crossing midnight",
+   "input": "22:00 - 02:00",
+   "now": "2026-11-02T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-11-02T03:00:00Z",
+   "end": "2026-11-02T07:00:00Z",
+   "live": false,
+   "echo": "4h  Nov 1, 10:00 pm - Nov 2, 2:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "fall: 1d is 24 real hours",
+   "input": "1d",
+   "now": "2026-11-02T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-11-01T17:00:00Z",
+   "end": "2026-11-02T17:00:00Z",
+   "live": true,
+   "echo": "1d  Nov 1, 12:00 pm - Nov 2, 12:00 pm (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "last month in January is December",
+   "input": "last month",
+   "now": "2026-01-15T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2025-12-01T05:00:00Z",
+   "end": "2026-01-01T05:00:00Z",
+   "live": false,
+   "echo": "31d  Dec 1, 2025, 12:00 am - Jan 1, 2026, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "last month in March is a 28 day February",
+   "input": "last month",
+   "now": "2026-03-15T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-02-01T05:00:00Z",
+   "end": "2026-03-01T05:00:00Z",
+   "live": false,
+   "echo": "28d  Feb 1, 12:00 am - Mar 1, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "last month in March of a leap year",
+   "input": "last month",
+   "now": "2024-03-15T16:00:00Z",
+   "zone": "America/New_York",
+   "start": "2024-02-01T05:00:00Z",
+   "end": "2024-03-01T05:00:00Z",
+   "live": false,
+   "echo": "29d  Feb 1, 12:00 am - Mar 1, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "last year in January",
+   "input": "last year",
+   "now": "2026-01-15T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2025-01-01T05:00:00Z",
+   "end": "2026-01-01T05:00:00Z",
+   "live": false,
+   "echo": "365d  Jan 1, 2025, 12:00 am - Jan 1, 2026, 12:00 am (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "year to date on January 1",
+   "input": "ytd",
+   "now": "2026-01-01T17:00:00Z",
+   "zone": "America/New_York",
+   "start": "2026-01-01T05:00:00Z",
+   "end": "2026-01-01T17:00:00Z",
+   "live": true,
+   "echo": "12h  Jan 1, 12:00 am - Jan 1, 12:00 pm (UTC-05:00)",
+   "error": null
+  },
+  {
+   "name": "month to date on the 31st",
+   "input": "month to date",
+   "now": "2026-10-31T23:30:00Z",
+   "zone": "America/New_York",
+   "start": "2026-10-01T04:00:00Z",
+   "end": "2026-10-31T23:30:00Z",
+   "live": true,
+   "echo": "30d  Oct 1, 12:00 am - Oct 31, 7:30 pm (UTC-04:00)",
+   "error": null
+  },
+  {
+   "name": "empty",
+   "input": "",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "empty"
+  },
+  {
+   "name": "blank",
+   "input": "   ",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "empty"
+  },
+  {
+   "name": "nonsense",
+   "input": "banana",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "unrecognized"
+  },
+  {
+   "name": "years are not a unit",
+   "input": "5 years",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "unrecognized"
+  },
+  {
+   "name": "shorter than the minimum",
+   "input": "3m",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "too_short"
+  },
+  {
+   "name": "zero",
+   "input": "0h",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "too_short"
+  },
+  {
+   "name": "a typed range under the minimum",
+   "input": "10:00 - 10:03",
+   "now": "2026-10-08T20:00:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "too_short"
+  },
+  {
+   "name": "today just after midnight",
+   "input": "today",
+   "now": "2026-10-08T04:02:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "too_short"
+  },
+  {
+   "name": "end before start",
+   "input": "Oct 2 - Oct 1",
+   "now": "2026-10-08T20:00:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "end_before_start"
+  },
+  {
+   "name": "a single time needs an end",
+   "input": "13:00",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "needs_end"
+  },
+  {
+   "name": "a date and time needs an end",
+   "input": "Oct 1 12pm",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "needs_end"
+  },
+  {
+   "name": "now alone",
+   "input": "now",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "needs_end"
+  },
+  {
+   "name": "no such day",
+   "input": "Feb 30",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "bad_date"
+  },
+  {
+   "name": "no such month",
+   "input": "13/1",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "bad_date"
+  },
+  {
+   "name": "a bad hour",
+   "input": "25:00 - 26:00",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "bad_time"
+  },
+  {
+   "name": "12 hour clock has no 13",
+   "input": "13pm - 2pm",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "bad_time"
+  },
+  {
+   "name": "since a start in the future",
+   "input": "since Dec 25 2030",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "start_in_future"
+  },
+  {
+   "name": "now cannot start",
+   "input": "now - Oct 1",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "bad_range"
+  },
+  {
+   "name": "two separators",
+   "input": "Oct 1 - Oct 2 - Oct 3",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "bad_range"
+  },
+  {
+   "name": "too far back",
+   "input": "99999999 days",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "too_far_back"
+  }
+ ]
+}
diff --git a/Darling/Darling.Tests/TimeRangeTests.cs b/Darling/Darling.Tests/TimeRangeTests.cs
new file mode 100644
index 0000000000..40a3c372d0
--- /dev/null
+++ b/Darling/Darling.Tests/TimeRangeTests.cs
@@ -0,0 +1,284 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using PerformanceMonitor.Ui;
+using Xunit;
+
+/* This file is compiled into Darling.Tests and Lite.Tests (a linked Compile item), so both test assemblies pin the
+   shared picker model; the namespace is the same in each. */
+namespace Darling.Tests;
+
+/// <summary>
+/// #5562: the shared time range grammar. Every row of <c>Fixtures/time-range-cases.json</c> must parse to the
+/// stated instants, liveness and echo text (or the stated error code); the web module runs the same file.
+/// </summary>
+public sealed class TimeRangeFixtureTests
+{
+    private static readonly string FixturePath = Path.Combine(AppContext.BaseDirectory, "Fixtures", "time-range-cases.json");
+
+    public static IEnumerable<object[]> Cases()
+    {
+        using var doc = JsonDocument.Parse(File.ReadAllText(FixturePath));
+        foreach (var c in doc.RootElement.GetProperty("cases").EnumerateArray())
+        {
+            yield return new object[] { c.GetProperty("name").GetString()! + " [" + c.GetProperty("input").GetString() + "]" , c.GetRawText() };
+        }
+    }
+
+    [Fact]
+    public void Fixture_UsesZoneIdsThisRuntimeResolves()
+    {
+        using var doc = JsonDocument.Parse(File.ReadAllText(FixturePath));
+        var zones = doc.RootElement.GetProperty("cases").EnumerateArray().Select(c => c.GetProperty("zone").GetString()!).Distinct().ToList();
+        Assert.NotEmpty(zones);
+        foreach (var id in zones)
+        {
+            Assert.NotNull(TimeZoneInfo.FindSystemTimeZoneById(id));
+        }
+    }
+
+    [Theory]
+    [MemberData(nameof(Cases))]
+    public void Parse_MatchesTheSharedFixture(string label, string caseJson)
+    {
+        Assert.False(string.IsNullOrEmpty(label));
+        using var doc = JsonDocument.Parse(caseJson);
+        var c = doc.RootElement;
+        var input = c.GetProperty("input").GetString();
+        var now = ParseZ(c.GetProperty("now").GetString()!);
+        var zone = TimeZoneInfo.FindSystemTimeZoneById(c.GetProperty("zone").GetString()!);
+
+        var result = TimeRangeParser.Parse(input, now, zone);
+
+        var expectedError = c.GetProperty("error");
+        if (expectedError.ValueKind == JsonValueKind.String)
+        {
+            Assert.False(result.Ok, "expected an error but got " + result.Echo);
+            Assert.Equal(expectedError.GetString(), result.ErrorCode);
+            Assert.False(string.IsNullOrWhiteSpace(result.Error));
+            Assert.Equal(string.Empty, result.Echo);
+            return;
+        }
+
+        Assert.True(result.Ok, result.ErrorCode + ": " + result.Error);
+        Assert.Equal(c.GetProperty("start").GetString(), Z(result.Range!.StartUtc));
+        Assert.Equal(c.GetProperty("end").GetString(), Z(result.Range!.EndUtc));
+        Assert.Equal(c.GetProperty("live").GetBoolean(), result.Range.IsLive);
+        Assert.Equal(c.GetProperty("echo").GetString(), result.Echo);
+    }
+
+    internal static DateTime ParseZ(string iso)
+        => DateTime.SpecifyKind(DateTime.ParseExact(iso, "yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture, DateTimeStyles.None), DateTimeKind.Unspecified);
+
+    internal static string Z(DateTime naiveUtc)
+        => naiveUtc.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture);
+}
+
+/// <summary>#5562: the preset lists, calendar periods, ids, legacy hour mapping and the notes beside the picker.</summary>
+public sealed class TimeRangeModelTests
+{
+    private static readonly TimeZoneInfo NewYork = TimeZoneInfo.FindSystemTimeZoneById("America/New_York");
+    private static readonly DateTime Now = new(2026, 10, 8, 11, 1, 0, DateTimeKind.Unspecified);
+
+    [Fact]
+    public void RollingPresets_AreTheNineShortOnesInOrder()
+    {
+        Assert.Equal(new[] { "5m", "15m", "30m", "1h", "4h", "1d", "2d", "1w", "1mo" }, TimeRangePresets.Rolling.Select(p => p.Id));
+    }
+
+    [Fact]
+    public void CalendarPeriods_AreTheEightInOrder()
+    {
+        Assert.Equal(
+            new[] { "Today", "Yesterday", "Week to Date", "Previous Week", "Month to Date", "Previous Month", "Year to Date", "Previous Year" },
+            TimeRangePresets.CalendarPeriods.Select(p => p.Name));
+    }
+
+    [Fact]
+    public void CalendarPeriods_ReportTheirCurrentLength()
+    {
+        // Thursday 7:01 am in New York: Week to Date is Monday 00:00 to now.
+        Assert.Equal("3d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.WeekToDate), Now, NewYork));
+        Assert.Equal("7h 1m", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), Now, NewYork));
+        Assert.Equal("1d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday), Now, NewYork));
+        Assert.Equal("7d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek), Now, NewYork));
+        Assert.Equal("30d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousMonth), Now, NewYork));
+        Assert.Equal("365d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousYear), Now, NewYork));
+        // Just after midnight Today is under the minimum, so it has no length to show.
+        Assert.Null(TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), new DateTime(2026, 10, 8, 4, 2, 0), NewYork));
+    }
+
+    [Fact]
+    public void ShortDaysOnTheChangeDays_ReadAs23And25Hours()
+    {
+        var spec = TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday);
+        Assert.Equal("23h", TimeRangePresets.CurrentLength(spec, new DateTime(2026, 3, 9, 16, 0, 0), NewYork));
+        Assert.Equal("1d", TimeRangePresets.CurrentLength(spec, new DateTime(2026, 11, 2, 17, 0, 0), NewYork));
+        Assert.True(spec.TryResolve(new DateTime(2026, 11, 2, 17, 0, 0), NewYork, out var longDay, out _));
+        Assert.Equal(TimeSpan.FromHours(25), longDay!.Span);
+    }
+
+    [Fact]
+    public void ConsecutivePeriods_TileWithNoGap()
+    {
+        var now = new DateTime(2026, 3, 9, 16, 0, 0);
+        Assert.True(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek).TryResolve(now, NewYork, out var lastWeek, out _));
+        Assert.True(TimeRangeSpec.ForPeriod(CalendarPeriod.WeekToDate).TryResolve(now, NewYork, out var thisWeek, out _));
+        Assert.Equal(lastWeek!.EndUtc, thisWeek!.StartUtc);
+    }
+
+    [Theory]
+    [InlineData(1, "1h")]
+    [InlineData(4, "4h")]
+    [InlineData(12, "12h")]
+    [InlineData(24, "1d")]
+    [InlineData(168, "1w")]
+    [InlineData(48, "2d")]
+    [InlineData(720, "1mo")]
+    [InlineData(36, "36h")]
+    [InlineData(2160, "90d")]
+    public void FromLegacyHours_MapsWholeHours(int hours, string expectedId)
+    {
+        var spec = TimeRangePresets.FromLegacyHours(hours);
+        Assert.NotNull(spec);
+        Assert.Equal(expectedId, spec!.Id);
+        Assert.Equal(hours, spec.WholeHours);
+        Assert.True(spec.TryResolve(Now, NewYork, out var range, out _));
+        Assert.Equal(TimeSpan.FromHours(hours), range!.Span);
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-4)]
+    public void FromLegacyHours_RefusesZeroAndNegative(int hours)
+        => Assert.Null(TimeRangePresets.FromLegacyHours(hours));
+
+    [Fact]
+    public void Ids_RoundTrip()
+    {
+        var specs = TimeRangePresets.Rolling.Concat(TimeRangePresets.CalendarPeriods).ToList();
+        specs.Add(TimeRangeSpec.Relative(TimeSpan.FromMinutes(90)));
+        specs.Add(TimeRangeSpec.FixedRange(new DateTime(2026, 10, 1, 4, 0, 0), new DateTime(2026, 10, 3, 4, 0, 0)));
+        specs.Add(TimeRangeSpec.SinceInstant(new DateTime(2026, 10, 1, 4, 0, 0)));
+        foreach (var spec in specs)
+        {
+            Assert.True(TimeRangeSpec.TryFromId(spec.Id, out var back), spec.Id);
+            Assert.Equal(spec, back);
+        }
+
+        Assert.False(TimeRangeSpec.TryFromId("", out _));
+        Assert.False(TimeRangeSpec.TryFromId("tomorrow", out _));
+        Assert.False(TimeRangeSpec.TryFromId("0h", out _));
+        Assert.False(TimeRangeSpec.TryFromId("h", out _));
+        Assert.Equal(TimeSpan.FromDays(60), TimeRangeSpec.TryFromId("2mo", out var twoMonths) ? twoMonths!.Span : default);
+    }
+
+    [Fact]
+    public void TheMinimumIsFiveMinutes_AndNothingIsWidened()
+    {
+        Assert.True(TimeRangeSpec.Relative(TimeSpan.FromMinutes(5)).TryResolve(Now, NewYork, out _, out _));
+        Assert.False(TimeRangeSpec.Relative(TimeSpan.FromMinutes(4)).TryResolve(Now, NewYork, out var none, out var error));
+        Assert.Null(none);
+        Assert.Equal("too_short", error!.Code);
+        Assert.Contains("5 minutes", error.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void NoUpperCap_AYearsLongRangeResolves()
+    {
+        var result = TimeRangeParser.Parse("1000d", Now, NewYork);
+        Assert.True(result.Ok);
+        Assert.Equal(TimeSpan.FromDays(1000), result.Range!.Span);
+    }
+
+    [Fact]
+    public void TypedAndPresetRanges_AgreeOnTheSameInstants()
+    {
+        Assert.Equal(TimeRangeSpec.Relative(TimeSpan.FromDays(7)), TimeRangeParser.Parse("7d", Now, NewYork).Spec);
+        Assert.Equal(TimeRangePresets.Find("1mo"), TimeRangeParser.Parse("30 days", Now, NewYork).Spec);
+        Assert.Equal(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousMonth), TimeRangeParser.Parse("last month", Now, NewYork).Spec);
+        Assert.Equal(TimeRangeSpec.Relative(TimeSpan.FromDays(30)), TimeRangeParser.Parse("last 30 days", Now, NewYork).Spec);
+    }
+
+    [Fact]
+    public void Resolve_FollowsTheZone_ForCalendarPeriodsButNotForFixedRanges()
+    {
+        var today = TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday);
+        Assert.True(today.TryResolve(Now, NewYork, out var ny, out _));
+        Assert.True(today.TryResolve(Now, TimeZoneInfo.Utc, out var utc, out _));
+        Assert.NotEqual(ny!.StartUtc, utc!.StartUtc);
+
+        var fixedRange = TimeRangeParser.Parse("Oct 1", Now, NewYork).Spec!;
+        Assert.True(fixedRange.TryResolve(Now, NewYork, out var a, out _));
+        Assert.True(fixedRange.TryResolve(Now, TimeZoneInfo.Utc, out var b, out _));
+        Assert.Equal(a!.StartUtc, b!.StartUtc);
+        Assert.Equal(a.EndUtc, b.EndUtc);
+    }
+
+    [Fact]
+    public void LiveRanges_SlideWithNow()
+    {
+        var spec = TimeRangeParser.Parse("since 10/1", Now, NewYork).Spec!;
+        Assert.True(spec.TryResolve(Now, NewYork, out var first, out _));
+        Assert.True(spec.TryResolve(Now.AddHours(3), NewYork, out var later, out _));
+        Assert.Equal(first!.StartUtc, later!.StartUtc);
+        Assert.Equal(first.EndUtc.AddHours(3), later.EndUtc);
+        Assert.True(later.IsLive);
+    }
+
+    [Fact]
+    public void Label_ForTheIssueExample()
+    {
+        var result = TimeRangeParser.Parse("week to date", new DateTime(2026, 10, 8, 11, 1, 0), NewYork);
+        Assert.Equal("3d  Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)", result.Echo);
+        Assert.Equal("Oct 5, 12:00 am", result.Range!.StartText);
+        Assert.Equal("UTC-04:00", result.Range.ZoneText);
+    }
+
+    [Fact]
+    public void DataStartNote_AppearsOnlyWhenTheRangeStartsWellBeforeTheData()
+    {
+        Assert.True(TimeRangeSpec.Relative(TimeSpan.FromDays(7)).TryResolve(Now, NewYork, out var week, out _));
+        // Data begins Oct 3 2:00 pm EDT = 18:00Z; the week starts Oct 1 7:01 am EDT.
+        Assert.Equal("Data starts Oct 3, 2:00 pm", TimeRangeNotes.DataStartNote(week!, new DateTime(2026, 10, 3, 18, 0, 0)));
+        // Starting inside the 90 minute slack of the data's start says nothing.
+        Assert.Null(TimeRangeNotes.DataStartNote(week!, new DateTime(2026, 10, 1, 12, 0, 0)));
+        Assert.Null(TimeRangeNotes.DataStartNote(week!, null));
+        Assert.Null(TimeRangeNotes.DataStartNote(week!, new DateTime(2026, 9, 1)));
+    }
+
+    [Theory]
+    [InlineData(10, 5, "Data here is collected every 5 minutes.")]
+    [InlineData(14, 5, "Data here is collected every 5 minutes.")]
+    [InlineData(15, 5, null)]
+    [InlineData(5, 1, null)]
+    [InlineData(5, 2, "Data here is collected every 2 minutes.")]
+    [InlineData(120, 60, "Data here is collected every hour.")]
+    [InlineData(60, 0, null)]
+    public void SampleIntervalNote_FiresUnderThreeSamples(int spanMinutes, int intervalMinutes, string? expected)
+    {
+        TimeSpan? interval = intervalMinutes == 0 ? null : TimeSpan.FromMinutes(intervalMinutes);
+        Assert.Equal(expected, TimeRangeNotes.SampleIntervalNote(TimeSpan.FromMinutes(spanMinutes), interval));
+    }
+
+    [Fact]
+    public void FormatLength_FloorsAndDropsHoursPastADay()
+    {
+        Assert.Equal("45m", TimeRangeSpec.FormatLength(TimeSpan.FromMinutes(45)));
+        Assert.Equal("1h 30m", TimeRangeSpec.FormatLength(TimeSpan.FromMinutes(90)));
+        Assert.Equal("2h", TimeRangeSpec.FormatLength(TimeSpan.FromHours(2)));
+        Assert.Equal("1d", TimeRangeSpec.FormatLength(TimeSpan.FromHours(47)));
+        Assert.Equal("3d", TimeRangeSpec.FormatLength(new TimeSpan(3, 7, 1, 0)));
+    }
+}
diff --git a/Lite.Tests/Lite.Tests.csproj b/Lite.Tests/Lite.Tests.csproj
index 6753fc6ed0..b393361c01 100644
--- a/Lite.Tests/Lite.Tests.csproj
+++ b/Lite.Tests/Lite.Tests.csproj
@@ -61,6 +61,9 @@
     <!-- system_health event samples (one per feeder event; shapes per sp_HealthParser xpath) for the
          System Events reader round-trip tests. Mirrors Darling.Tests' Fixtures\SystemHealth set. -->
     <None Include="Fixtures\SystemHealth\*.xml" CopyToOutputDirectory="PreserveNewest" />
+    <!-- The shared time range cases and tests (#5562): one file each, linked from Darling.Tests so both assemblies run the same grammar. -->
+    <None Include="..\Darling\Darling.Tests\Fixtures\time-range-cases.json" Link="Fixtures\time-range-cases.json" CopyToOutputDirectory="PreserveNewest" />
+    <Compile Include="..\Darling\Darling.Tests\TimeRangeTests.cs" Link="TimeRangeTests.cs" />
     <!-- Lite's MCP host source, copied beside the test binary (it lives outside this project directory, so the
          default Compile glob never sees it) so HostHeaderGuardTests can pin that the #1648 DNS-rebinding
          middleware is installed FIRST, ahead of MapMcp. Mirrors Darling.Tests' guard on its two hosts — the
diff --git a/PerformanceMonitor.Ui/TimeRange/ResolvedTimeRange.cs b/PerformanceMonitor.Ui/TimeRange/ResolvedTimeRange.cs
new file mode 100644
index 0000000000..b49aa130d6
--- /dev/null
+++ b/PerformanceMonitor.Ui/TimeRange/ResolvedTimeRange.cs
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Globalization;
+
+namespace PerformanceMonitor.Ui;
+
+/// <summary>
+/// A <see cref="TimeRangeSpec"/> pinned to a now and a display zone (#5562): the naive-UTC start and end a tab
+/// reads, whether the end slides with now, and the one-line label the picker shows. Immutable; a live range is
+/// re-resolved (<see cref="TimeRangeSpec.TryResolve"/>) on each refresh.
+/// </summary>
+public sealed class ResolvedTimeRange
+{
+    internal ResolvedTimeRange(TimeRangeSpec spec, DateTime startUtc, DateTime endUtc, bool isLive, TimeZoneInfo zone, DateTime nowUtc)
+    {
+        Spec = spec;
+        StartUtc = startUtc;
+        EndUtc = endUtc;
+        IsLive = isLive;
+        Zone = zone;
+        NowUtc = nowUtc;
+    }
+
+    /// <summary>The range as named.</summary>
+    public TimeRangeSpec Spec { get; }
+
+    /// <summary>The first instant, naive UTC.</summary>
+    public DateTime StartUtc { get; }
+
+    /// <summary>The last instant, naive UTC. For a live range this is the now it was resolved at.</summary>
+    public DateTime EndUtc { get; }
+
+    /// <summary>True when the end slides with now: a relative range, Today and the to-date periods, and "since".</summary>
+    public bool IsLive { get; }
+
+    /// <summary>The display zone the range was resolved in.</summary>
+    public TimeZoneInfo Zone { get; }
+
+    /// <summary>The now the range was resolved at, naive UTC.</summary>
+    public DateTime NowUtc { get; }
+
+    /// <summary>The length of the range.</summary>
+    public TimeSpan Span => EndUtc - StartUtc;
+
+    /// <summary>The length as the picker words it ("3d", "7h 1m", "45m").</summary>
+    public string Length => TimeRangeSpec.FormatLength(Span);
+
+    /// <summary>The start as text in the display zone: "Oct 5, 12:00 am" (the year too when a bound is not in now's year).</summary>
+    public string StartText => FormatBound(StartUtc, includeSeconds: Spec.Kind == TimeRangeKind.Fixed);
+
+    /// <summary>The end as text in the display zone, like <see cref="StartText"/>.</summary>
+    public string EndText => FormatBound(EndUtc, includeSeconds: Spec.Kind == TimeRangeKind.Fixed);
+
+    /// <summary>
+    /// The zone as the label words it: "UTC-04:00", or "UTC-05:00 to UTC-04:00" when a daylight saving change
+    /// falls between the two ends.
+    /// </summary>
+    public string ZoneText
+    {
+        get
+        {
+            var a = "UTC" + DisplayZone.UtcOffsetText(StartUtc, Zone);
+            var b = "UTC" + DisplayZone.UtcOffsetText(EndUtc, Zone);
+            return a == b ? a : a + " to " + b;
+        }
+    }
+
+    /// <summary>The one line the picker shows and the parser echoes: "3d  Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)".</summary>
+    public string Label => Length + "  " + StartText + " - " + EndText + " (" + ZoneText + ")";
+
+    /// <summary>
+    /// A moment as the picker prints it: month, day, 12-hour clock with lower-case am/pm, the year when this
+    /// range touches a year other than now's, and the UTC offset after a wall time that happens twice.
+    /// </summary>
+    internal string FormatBound(DateTime utc, bool includeSeconds)
+    {
+        var wall = DisplayZone.ToDisplay(utc, Zone);
+        var wallNow = DisplayZone.ToDisplay(NowUtc, Zone);
+        var showYear = DisplayZone.ToDisplay(StartUtc, Zone).Year != wallNow.Year || DisplayZone.ToDisplay(EndUtc, Zone).Year != wallNow.Year;
+        var text = TimeRangeFormat.Wall(wall, showYear, includeSeconds);
+        var suffix = DisplayZone.AmbiguousOffsetSuffix(utc, Zone);
+        return suffix is null ? text : text + " " + suffix;
+    }
+}
+
+/// <summary>The text forms the picker shares with the web module, so the shared fixture can pin them.</summary>
+internal static class TimeRangeFormat
+{
+    /// <summary>"Oct 5, 12:00 am", "Oct 5, 2025, 12:00 am", with ":ss" when asked and the seconds are not zero.</summary>
+    internal static string Wall(DateTime wall, bool showYear, bool includeSeconds)
+    {
+        var hour12 = wall.Hour % 12 == 0 ? 12 : wall.Hour % 12;
+        var clock = hour12.ToString(CultureInfo.InvariantCulture) + ":" + wall.Minute.ToString("00", CultureInfo.InvariantCulture);
+        if (includeSeconds && wall.Second != 0)
+        {
+            clock += ":" + wall.Second.ToString("00", CultureInfo.InvariantCulture);
+        }
+
+        var day = wall.ToString(showYear ? "MMM d, yyyy" : "MMM d", CultureInfo.InvariantCulture);
+        return day + ", " + clock + (wall.Hour < 12 ? " am" : " pm");
+    }
+}
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs
new file mode 100644
index 0000000000..ba14f26719
--- /dev/null
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs
@@ -0,0 +1,617 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Text.RegularExpressions;
+
+namespace PerformanceMonitor.Ui;
+
+/// <summary>What <see cref="TimeRangeParser.Parse"/> made of a line of text (#5562).</summary>
+public sealed class TimeRangeParseResult
+{
+    internal TimeRangeParseResult(ResolvedTimeRange range)
+    {
+        Range = range;
+        Echo = range.Label;
+    }
+
+    internal TimeRangeParseResult(string code, string message)
+    {
+        ErrorCode = code;
+        Error = message;
+        Echo = string.Empty;
+    }
+
+    /// <summary>The range, resolved at the now and zone the parse was given; <c>null</c> when the text was refused.</summary>
+    public ResolvedTimeRange? Range { get; }
+
+    /// <summary>What the picker shows before Apply: the range's one-line label ("3d  Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)"), empty on an error.</summary>
+    public string Echo { get; }
+
+    /// <summary>The plain reason the text was refused, or <c>null</c>.</summary>
+    public string? Error { get; }
+
+    /// <summary>A stable code for the refusal: empty, unrecognized, bad_date, bad_time, bad_range, needs_end, too_short, end_before_start, start_in_future, too_far_back. <c>null</c> on success.</summary>
+    public string? ErrorCode { get; }
+
+    /// <summary>The named range, or <c>null</c> on an error.</summary>
+    public TimeRangeSpec? Spec => Range?.Spec;
+
+    /// <summary>True when the text became a range.</summary>
+    public bool Ok => Range is not null;
+}
+
+/// <summary>
+/// One line of text to a time range (#5562). The picker's text box, the web module and the shared fixture
+/// (<c>time-range-cases.json</c>) all follow this grammar; the text is case-insensitive and commas, extra spaces and
+/// en or em dashes do not matter.
+///
+/// <list type="bullet">
+///   <item><b>Relative</b>: <c>45m</c>, <c>12 hours</c>, <c>10d</c>, <c>2 weeks</c>, <c>last 3 days</c>, <c>past 90 min</c>. Units m/min/minute(s), h/hr/hour(s),
+///   d/day(s), w/wk/week(s), mo/month(s) (a month is 30 real days). Counts may have a decimal part. Real elapsed time.</item>
+///   <item><b>Calendar</b>: <c>today</c>, <c>yesterday</c>, <c>this week</c> (<c>week to date</c>, <c>wtd</c>), <c>last week</c>, <c>this month</c>
+///   (<c>mtd</c>), <c>last month</c>, <c>this year</c> (<c>ytd</c>), <c>last year</c>; "previous" works for "last". Wall-clock days of the display zone, weeks start Monday.</item>
+///   <item><b>Fixed</b>: one point or two joined by <c>-</c>, <c>to</c> or <c>until</c>. A point is a date, a time, or both. Dates: <c>Oct 1</c>, <c>October 1 2025</c>,
+///   <c>1 Oct</c>, <c>10/1</c>, <c>10/1/2026</c> (month first), <c>2026-10-01</c>, <c>today</c>, <c>yesterday</c>. Times: <c>1:00 am</c>, <c>12pm</c>, <c>13:00</c>,
+///   <c>13:00:30</c>, <c>noon</c>, <c>midnight</c>. One date alone is the whole day; in a range a date alone as the end includes that whole day. A time alone takes
+///   the other end's date, or the latest day that is not in the future. A date without a year is the latest such date not in the future.</item>
+///   <item><b>Growing</b>: <c>since 10/1</c>, <c>Oct 2 12pm to now</c>. The end slides with now.</item>
+///   <item><b>Unix</b>: <c>1790852543 - 1791457343</c>; ten digits are seconds, thirteen are milliseconds.</item>
+/// </list>
+///
+/// <para>Typed wall times resolve through <see cref="DisplayZone.ToUtcBound"/> (the start takes the earliest instant,
+/// the end the latest; a repeated hour widens, a skipped time maps to the change instant). Nothing shorter than
+/// <see cref="TimeRangeSpec.MinimumSpan"/> is accepted, and nothing is widened. Pure: the caller gives the now and
+/// the zone.</para>
+/// </summary>
+public static class TimeRangeParser
+{
+    private const string Examples = "Try 45m, 3 days, last month, Oct 1 - Oct 2 or 1:00 am - 7:00 am.";
+
+    private static readonly Regex RelativeRx = new(@"^(?:(?:last|past|previous)\s+)?(\d+(?:\.\d+)?)\s*([a-z]+)$", RegexOptions.CultureInvariant);
+    private static readonly Regex SeparatorRx = new(@"\s+(?:-|to|until)\s+", RegexOptions.CultureInvariant);
+    private static readonly Regex UnixRx = new(@"^(?:\d{10}|\d{13})$", RegexOptions.CultureInvariant);
+    private static readonly Regex IsoTRx = new(@"(\d{4}-\d{1,2}-\d{1,2})t(\d)", RegexOptions.CultureInvariant);
+    private static readonly Regex Time12Rx = new(@"(?:^|\s)(\d{1,2})(?::(\d{2}))?(?::(\d{2}))?\s*(am|pm)$", RegexOptions.CultureInvariant);
+    private static readonly Regex Time24Rx = new(@"(?:^|\s)(\d{1,2}):(\d{2})(?::(\d{2}))?$", RegexOptions.CultureInvariant);
+    private static readonly Regex TimeWordRx = new(@"(?:^|\s)(noon|midnight)$", RegexOptions.CultureInvariant);
+    private static readonly Regex MonthDayRx = new(@"^([a-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?(?:\s+(\d{4}))?$", RegexOptions.CultureInvariant);
+    private static readonly Regex DayMonthRx = new(@"^(\d{1,2})(?:st|nd|rd|th)?\s+([a-z]+)(?:\s+(\d{4}))?$", RegexOptions.CultureInvariant);
+    private static readonly Regex SlashRx = new(@"^(\d{1,2})/(\d{1,2})(?:/(\d{4}|\d{2}))?$", RegexOptions.CultureInvariant);
+    private static readonly Regex IsoRx = new(@"^(\d{4})-(\d{1,2})-(\d{1,2})$", RegexOptions.CultureInvariant);
+    private static readonly Regex SpacesRx = new(@"\s+", RegexOptions.CultureInvariant);
+
+    private static readonly Dictionary<string, CalendarPeriod> Periods = new(StringComparer.Ordinal)
+    {
+        ["today"] = CalendarPeriod.Today,
+        ["yesterday"] = CalendarPeriod.Yesterday,
+        ["this week"] = CalendarPeriod.WeekToDate,
+        ["week to date"] = CalendarPeriod.WeekToDate,
+        ["wtd"] = CalendarPeriod.WeekToDate,
+        ["last week"] = CalendarPeriod.PreviousWeek,
+        ["previous week"] = CalendarPeriod.PreviousWeek,
+        ["this month"] = CalendarPeriod.MonthToDate,
+        ["month to date"] = CalendarPeriod.MonthToDate,
+        ["mtd"] = CalendarPeriod.MonthToDate,
+        ["last month"] = CalendarPeriod.PreviousMonth,
+        ["previous month"] = CalendarPeriod.PreviousMonth,
+        ["this year"] = CalendarPeriod.YearToDate,
+        ["year to date"] = CalendarPeriod.YearToDate,
+        ["ytd"] = CalendarPeriod.YearToDate,
+        ["last year"] = CalendarPeriod.PreviousYear,
+        ["previous year"] = CalendarPeriod.PreviousYear
+    };
+
+    private static readonly Dictionary<string, int> Months = new(StringComparer.Ordinal)
+    {
+        ["jan"] = 1, ["january"] = 1, ["feb"] = 2, ["february"] = 2, ["mar"] = 3, ["march"] = 3,
+        ["apr"] = 4, ["april"] = 4, ["may"] = 5, ["jun"] = 6, ["june"] = 6, ["jul"] = 7, ["july"] = 7,
+        ["aug"] = 8, ["august"] = 8, ["sep"] = 9, ["sept"] = 9, ["september"] = 9,
+        ["oct"] = 10, ["october"] = 10, ["nov"] = 11, ["november"] = 11, ["dec"] = 12, ["december"] = 12
+    };
+
+    private static readonly Dictionary<string, double> Units = new(StringComparer.Ordinal)
+    {
+        ["m"] = 60, ["min"] = 60, ["mins"] = 60, ["minute"] = 60, ["minutes"] = 60,
+        ["h"] = 3600, ["hr"] = 3600, ["hrs"] = 3600, ["hour"] = 3600, ["hours"] = 3600,
+        ["d"] = 86400, ["day"] = 86400, ["days"] = 86400,
+        ["w"] = 604800, ["wk"] = 604800, ["wks"] = 604800, ["week"] = 604800, ["weeks"] = 604800,
+        ["mo"] = 2592000, ["month"] = 2592000, ["months"] = 2592000
+    };
+
+    /// <summary>One side of a typed range, before it has a year, a day or a zone.</summary>
+    private sealed class Point
+    {
+        public bool IsNow;
+        public DateTime? InstantUtc;
+        public bool HasDate;
+        public int? Year;
+        public int Month;
+        public int Day;
+        public TimeSpan? Time;
+    }
+
+    private sealed class ParseFailure : Exception
+    {
+        public ParseFailure(string code, string message)
+            : base(message)
+        {
+            Code = code;
+        }
+
+        public string Code { get; }
+    }
+
+    /// <summary>Reads <paramref name="text"/> as a range at <paramref name="nowUtc"/> (naive UTC) in <paramref name="zone"/>.</summary>
+    public static TimeRangeParseResult Parse(string? text, DateTime nowUtc, TimeZoneInfo zone)
+    {
+        var now = TimeRangeSpec.Naive(nowUtc);
+        try
+        {
+            var spec = ParseSpec(text, now, zone);
+            return spec.TryResolve(now, zone, out var range, out var error)
+                ? new TimeRangeParseResult(range!)
+                : new TimeRangeParseResult(error!.Code, error.Message);
+        }
+        catch (ParseFailure ex)
+        {
+            return new TimeRangeParseResult(ex.Code, ex.Message);
+        }
+        catch (ArgumentOutOfRangeException)
+        {
+            return new TimeRangeParseResult("bad_date", "That date is out of range.");
+        }
+    }
+
+    private static TimeRangeSpec ParseSpec(string? text, DateTime now, TimeZoneInfo zone)
+    {
+        var s = Normalize(text);
+        if (s.Length == 0)
+        {
+            throw new ParseFailure("empty", "Type a range. " + Examples);
+        }
+
+        if (Periods.TryGetValue(s, out var period))
+        {
+            return TimeRangeSpec.ForPeriod(period);
+        }
+
+        var relative = RelativeRx.Match(s);
+        if (relative.Success && Units.TryGetValue(relative.Groups[2].Value, out var unitSeconds))
+        {
+            var count = double.Parse(relative.Groups[1].Value, CultureInfo.InvariantCulture);
+            var seconds = count * unitSeconds;
+            if (seconds > 36500d * 86400d)
+            {
+                throw new ParseFailure("too_far_back", "That reaches back more than 100 years.");
+            }
+
+            return TimeRangeSpec.Relative(TimeSpan.FromSeconds(Math.Round(seconds)));
+        }
+
+        var wallNow = DisplayZone.ToDisplay(now, zone);
+        if (s.StartsWith("since ", StringComparison.Ordinal))
+        {
+            return SinceSpec(ParsePoint(s.Substring(6), wallNow), wallNow, zone);
+        }
+
+        if (s.StartsWith("from ", StringComparison.Ordinal))
+        {
+            s = s.Substring(5);
+        }
+
+        var sides = SplitSides(s);
+        if (sides.Count == 1)
+        {
+            var only = ParsePoint(sides[0], wallNow);
+            if (only.IsNow || only.InstantUtc is not null || !only.HasDate || only.Time is not null)
+            {
+                throw new ParseFailure("needs_end", "Give an end as well, like \"Oct 1 12pm - 3pm\", or say \"since Oct 1 12pm\".");
+            }
+
+            /* One date alone is the whole day. */
+            var day = DateFor(only, wallNow, null);
+            return FixedSpec(day, day.AddDays(1), zone);
+        }
+
+        var a = ParsePoint(sides[0], wallNow);
+        var b = ParsePoint(sides[1], wallNow);
+        if (a.IsNow)
+        {
+            throw new ParseFailure("bad_range", "The start cannot be now. Use \"since\" for a range that grows.");
+        }
+
+        if (b.IsNow)
+        {
+            return SinceSpec(a, wallNow, zone);
+        }
+
+        if (a.InstantUtc is not null || b.InstantUtc is not null)
+        {
+            if (a.InstantUtc is null || b.InstantUtc is null)
+            {
+                throw new ParseFailure("bad_range", "Use two Unix times, or two dates and times, not one of each.");
+            }
+
+            return TimeRangeSpec.FixedRange(a.InstantUtc.Value, b.InstantUtc.Value);
+        }
+
+        return RangeSpec(a, b, wallNow, zone);
+    }
+
+    private static TimeRangeSpec FixedSpec(DateTime startWall, DateTime endWall, TimeZoneInfo zone)
+        => TimeRangeSpec.FixedRange(
+            DisplayZone.ToUtcBound(startWall, zone, BoundSide.From),
+            DisplayZone.ToUtcBound(endWall, zone, BoundSide.To));
+
+    private static TimeRangeSpec SinceSpec(Point start, DateTime wallNow, TimeZoneInfo zone)
+    {
+        if (start.IsNow)
+        {
+            throw new ParseFailure("bad_range", "The start cannot be now.");
+        }
+
+        if (start.InstantUtc is not null)
+        {
+            return TimeRangeSpec.SinceInstant(start.InstantUtc.Value);
+        }
+
+        DateTime wall;
+        if (start.HasDate)
+        {
+            wall = DateFor(start, wallNow, start.Time) + (start.Time ?? TimeSpan.Zero);
+        }
+        else
+        {
+            /* A time alone is the latest such time that is not in the future. */
+            wall = wallNow.Date + start.Time!.Value;
+            if (wall > wallNow)
+            {
+                wall = wall.AddDays(-1);
+            }
+        }
+
+        return TimeRangeSpec.SinceInstant(DisplayZone.ToUtcBound(wall, zone, BoundSide.From));
+    }
+
+    private static TimeRangeSpec RangeSpec(Point a, Point b, DateTime wallNow, TimeZoneInfo zone)
+    {
+        DateTime aDate;
+        DateTime bDate;
+
+        if (a.HasDate && b.HasDate)
+        {
+            if (a.Year is null && b.Year is null)
+            {
+                aDate = DateFor(a, wallNow, a.Time);
+                bDate = WithYear(b, aDate.Year);
+                bDate = RollEndIntoNextYear(b, aDate, bDate, wallNow);
+            }
+            else if (a.Year is null)
+            {
+                bDate = WithYear(b, b.Year!.Value);
+                aDate = WithYear(a, bDate.Year);
+                if (aDate > bDate)
+                {
+                    aDate = WithYear(a, bDate.Year - 1);
+                }
+            }
+            else
+            {
+                aDate = WithYear(a, a.Year.Value);
+                bDate = WithYear(b, b.Year ?? aDate.Year);
+                if (b.Year is null)
+                {
+                    bDate = RollEndIntoNextYear(b, aDate, bDate, wallNow);
+                }
+            }
+
+            if (bDate < aDate)
+            {
+                throw new ParseFailure("end_before_start", "The end is before the start.");
+            }
+        }
+        else if (a.HasDate)
+        {
+            aDate = DateFor(a, wallNow, a.Time);
+            bDate = aDate;
+            if (b.Time!.Value < (a.Time ?? TimeSpan.Zero))
+            {
+                bDate = aDate.AddDays(1);
+            }
+        }
+        else if (b.HasDate)
+        {
+            bDate = DateFor(b, wallNow, b.Time);
+            aDate = bDate;
+            if (b.Time is not null && a.Time!.Value > b.Time.Value)
+            {
+                aDate = bDate.AddDays(-1);
+            }
+        }
+        else
+        {
+            /* Two times: the latest day whose range has ended by now; an end earlier on the clock than the start is the next day. */
+            var rollsOver = b.Time!.Value < a.Time!.Value ? 1 : 0;
+            aDate = wallNow.Date;
+            for (var back = 0; back < 3; back++)
+            {
+                aDate = wallNow.Date.AddDays(-back);
+                if (aDate.AddDays(rollsOver) + b.Time.Value <= wallNow)
+                {
+                    break;
+                }
+            }
+
+            bDate = aDate.AddDays(rollsOver);
+        }
+
+        var startWall = aDate + (a.Time ?? TimeSpan.Zero);
+        var endWall = b.Time is null ? bDate.AddDays(1) : bDate + b.Time.Value;
+        return FixedSpec(startWall, endWall, zone);
+    }
+
+    /// <summary>
+    /// An end typed without a year that falls before its start ("Dec 30 - Jan 2") means the next year, but only when
+    /// that end has already happened: "Oct 2 - Oct 1" is a mistake, not a range into next year.
+    /// </summary>
+    private static DateTime RollEndIntoNextYear(Point end, DateTime startDate, DateTime endDate, DateTime wallNow)
+    {
+        if (endDate >= startDate || startDate.Year >= 9999)
+        {
+            return endDate;
+        }
+
+        try
+        {
+            var next = WithYear(end, startDate.Year + 1);
+            return next <= wallNow ? next : endDate;
+        }
+        catch (ParseFailure)
+        {
+            return endDate;
+        }
+    }
+
+    /// <summary>The calendar day of a point that has a date. Without a year it is the latest such day-and-time not after now.</summary>
+    private static DateTime DateFor(Point p, DateTime wallNow, TimeSpan? time)
+    {
+        if (p.Year is not null)
+        {
+            return WithYear(p, p.Year.Value);
+        }
+
+        for (var year = wallNow.Year; year >= wallNow.Year - 8; year--)
+        {
+            if (p.Day <= DateTime.DaysInMonth(year, p.Month))
+            {
+                var candidate = new DateTime(year, p.Month, p.Day, 0, 0, 0, DateTimeKind.Unspecified);
+                if (candidate + (time ?? TimeSpan.Zero) <= wallNow)
+                {
+                    return candidate;
+                }
+            }
+        }
+
+        throw new ParseFailure("bad_date", "That date does not exist.");
+    }
+
+    private static DateTime WithYear(Point p, int year)
+    {
+        if (year < 1 || year > 9999 || p.Day > DateTime.DaysInMonth(year, p.Month))
+        {
+            throw new ParseFailure("bad_date", "That date does not exist.");
+        }
+
+        return new DateTime(year, p.Month, p.Day, 0, 0, 0, DateTimeKind.Unspecified);
+    }
+
+    private static string Normalize(string? text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+        {
+            return string.Empty;
+        }
+
+        var s = text.Trim().ToLowerInvariant();
+        s = s.Replace('–', '-').Replace('—', '-').Replace('−', '-').Replace(',', ' ');
+        return SpacesRx.Replace(s, " ").Trim();
+    }
+
+    /// <summary>Splits on one separator: " - ", " to ", " until ", or, with none of those, a single dash. Two or more dashes and no spaced separator is one point (an ISO date).</summary>
+    private static List<string> SplitSides(string s)
+    {
+        var parts = SeparatorRx.Split(s);
+        if (parts.Length == 1)
+        {
+            var dashes = s.Split('-');
+            if (dashes.Length == 2)
+            {
+                parts = dashes;
+            }
+        }
+
+        if (parts.Length > 2)
+        {
+            throw new ParseFailure("bad_range", "Use one start and one end. " + Examples);
+        }
+
+        var sides = new List<string>();
+        foreach (var part in parts)
+        {
+            var side = part.Trim();
+            if (side.Length == 0)
+            {
+                throw new ParseFailure("unrecognized", "A range needs something on both sides of the dash. " + Examples);
+            }
+
+            sides.Add(side);
+        }
+
+        return sides;
+    }
+
+    private static Point ParsePoint(string text, DateTime wallNow)
+    {
+        var p = text.Trim();
+        if (p == "now")
+        {
+            return new Point { IsNow = true };
+        }
+
+        if (UnixRx.IsMatch(p))
+        {
+            var number = long.Parse(p, CultureInfo.InvariantCulture);
+            var seconds = p.Length == 13 ? number / 1000d : number;
+            var instant = DateTime.UnixEpoch.AddSeconds(seconds);
+            return new Point { InstantUtc = DateTime.SpecifyKind(instant, DateTimeKind.Unspecified) };
+        }
+
+        p = IsoTRx.Replace(p, "$1 $2");
+        if (p.StartsWith("at ", StringComparison.Ordinal))
+        {
+            p = p.Substring(3);
+        }
+        else if (p.StartsWith("on ", StringComparison.Ordinal))
+        {
+            p = p.Substring(3);
+        }
+
+        p = p.Replace(" at ", " ");
+
+        var point = new Point();
+        var datePart = p;
+        var m12 = Time12Rx.Match(p);
+        var m24 = Time24Rx.Match(p);
+        var mWord = TimeWordRx.Match(p);
+        if (m12.Success)
+        {
+            var hour = int.Parse(m12.Groups[1].Value, CultureInfo.InvariantCulture);
+            var minute = m12.Groups[2].Success ? int.Parse(m12.Groups[2].Value, CultureInfo.InvariantCulture) : 0;
+            var second = m12.Groups[3].Success ? int.Parse(m12.Groups[3].Value, CultureInfo.InvariantCulture) : 0;
+            if (hour < 1 || hour > 12 || minute > 59 || second > 59)
+            {
+                throw new ParseFailure("bad_time", "\"" + m12.Value.Trim() + "\" is not a time on a 12-hour clock.");
+            }
+
+            var pm = m12.Groups[4].Value == "pm";
+            point.Time = new TimeSpan((hour % 12) + (pm ? 12 : 0), minute, second);
+            datePart = p.Substring(0, m12.Index);
+        }
+        else if (m24.Success)
+        {
+            var hour = int.Parse(m24.Groups[1].Value, CultureInfo.InvariantCulture);
+            var minute = int.Parse(m24.Groups[2].Value, CultureInfo.InvariantCulture);
+            var second = m24.Groups[3].Success ? int.Parse(m24.Groups[3].Value, CultureInfo.InvariantCulture) : 0;
+            if (hour > 23 || minute > 59 || second > 59)
+            {
+                throw new ParseFailure("bad_time", "\"" + m24.Value.Trim() + "\" is not a time on a 24-hour clock.");
+            }
+
+            point.Time = new TimeSpan(hour, minute, second);
+            datePart = p.Substring(0, m24.Index);
+        }
+        else if (mWord.Success)
+        {
+            point.Time = mWord.Groups[1].Value == "noon" ? TimeSpan.FromHours(12) : TimeSpan.Zero;
+            datePart = p.Substring(0, mWord.Index);
+        }
+
+        datePart = datePart.Trim();
+        if (datePart.Length == 0)
+        {
+            if (point.Time is null)
+            {
+                throw new ParseFailure("unrecognized", "\"" + text.Trim() + "\" is not a date or a time. " + Examples);
+            }
+
+            return point;
+        }
+
+        ParseDate(datePart, point, wallNow, text);
+        return point;
+    }
+
+    private static void ParseDate(string d, Point point, DateTime wallNow, string original)
+    {
+        point.HasDate = true;
+        if (d == "today" || d == "yesterday")
+        {
+            var day = d == "today" ? wallNow.Date : wallNow.Date.AddDays(-1);
+            point.Year = day.Year;
+            point.Month = day.Month;
+            point.Day = day.Day;
+            return;
+        }
+
+        int year = 0;
+        int month;
+        int dayOfMonth;
+        var yearText = string.Empty;
+
+        var md = MonthDayRx.Match(d);
+        var dm = DayMonthRx.Match(d);
+        var slash = SlashRx.Match(d);
+        var iso = IsoRx.Match(d);
+        if (md.Success && Months.TryGetValue(md.Groups[1].Value, out month))
+        {
+            dayOfMonth = int.Parse(md.Groups[2].Value, CultureInfo.InvariantCulture);
+            yearText = md.Groups[3].Value;
+        }
+        else if (dm.Success && Months.TryGetValue(dm.Groups[2].Value, out month))
+        {
+            dayOfMonth = int.Parse(dm.Groups[1].Value, CultureInfo.InvariantCulture);
+            yearText = dm.Groups[3].Value;
+        }
+        else if (slash.Success)
+        {
+            month = int.Parse(slash.Groups[1].Value, CultureInfo.InvariantCulture);
+            dayOfMonth = int.Parse(slash.Groups[2].Value, CultureInfo.InvariantCulture);
+            yearText = slash.Groups[3].Value;
+            if (yearText.Length == 2)
+            {
+                yearText = "20" + yearText;
+            }
+        }
+        else if (iso.Success)
+        {
+            yearText = iso.Groups[1].Value;
+            month = int.Parse(iso.Groups[2].Value, CultureInfo.InvariantCulture);
+            dayOfMonth = int.Parse(iso.Groups[3].Value, CultureInfo.InvariantCulture);
+        }
+        else
+        {
+            throw new ParseFailure("unrecognized", "\"" + original.Trim() + "\" is not a date or a time. " + Examples);
+        }
+
+        if (month < 1 || month > 12 || dayOfMonth < 1 || dayOfMonth > 31)
+        {
+            throw new ParseFailure("bad_date", "\"" + original.Trim() + "\" is not a date that exists.");
+        }
+
+        if (yearText.Length > 0)
+        {
+            year = int.Parse(yearText, CultureInfo.InvariantCulture);
+            if (year < 1900 || year > 9999 || dayOfMonth > DateTime.DaysInMonth(year, month))
+            {
+                throw new ParseFailure("bad_date", "\"" + original.Trim() + "\" is not a date that exists.");
+            }
+
+            point.Year = year;
+        }
+        else if (dayOfMonth > DateTime.DaysInMonth(2024, month))
+        {
+            throw new ParseFailure("bad_date", "\"" + original.Trim() + "\" is not a date that exists.");
+        }
+
+        point.Month = month;
+        point.Day = dayOfMonth;
+    }
+}
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
new file mode 100644
index 0000000000..dd4fd9f1ee
--- /dev/null
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+
+namespace PerformanceMonitor.Ui;
+
+/// <summary>
+/// The ranges the picker lists (#5562): nine short presets and eight calendar periods. All are
+/// <see cref="TimeRangeSpec"/>s, so a preset, a typed range and a saved setting resolve through one path.
+/// </summary>
+public static class TimeRangePresets
+{
+    /// <summary>The short presets, shortest first: 5m 15m 30m 1h 4h 1d 2d 1w 1mo (1mo is 30 real days).</summary>
+    public static IReadOnlyList<TimeRangeSpec> Rolling { get; } = new[]
+    {
+        TimeRangeSpec.Relative(TimeSpan.FromMinutes(5)),
+        TimeRangeSpec.Relative(TimeSpan.FromMinutes(15)),
+        TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)),
+        TimeRangeSpec.Relative(TimeSpan.FromHours(1)),
+        TimeRangeSpec.Relative(TimeSpan.FromHours(4)),
+        TimeRangeSpec.Relative(TimeSpan.FromDays(1)),
+        TimeRangeSpec.Relative(TimeSpan.FromDays(2)),
+        TimeRangeSpec.Relative(TimeSpan.FromDays(7)),
+        TimeRangeSpec.Relative(TimeSpan.FromDays(30))
+    };
+
+    /// <summary>The calendar periods: Today, Yesterday, Week to Date, Previous Week, Month to Date, Previous Month, Year to Date, Previous Year.</summary>
+    public static IReadOnlyList<TimeRangeSpec> CalendarPeriods { get; } = new[]
+    {
+        TimeRangeSpec.ForPeriod(CalendarPeriod.Today),
+        TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday),
+        TimeRangeSpec.ForPeriod(CalendarPeriod.WeekToDate),
+        TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek),
+        TimeRangeSpec.ForPeriod(CalendarPeriod.MonthToDate),
+        TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousMonth),
+        TimeRangeSpec.ForPeriod(CalendarPeriod.YearToDate),
+        TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousYear)
+    };
+
+    /// <summary>The range the old hour lists meant: 1, 4, 12, 24 and 168 hours, and any other whole number of hours. <c>null</c> for zero or less.</summary>
+    /// <remarks>24 hours is "1d" and 168 is "1w": the same instants, the id the new lists use.</remarks>
+    public static TimeRangeSpec? FromLegacyHours(int hours)
+        => hours <= 0 ? null : TimeRangeSpec.Relative(TimeSpan.FromHours(hours));
+
+    /// <summary>The length of a calendar period at <paramref name="nowUtc"/> in <paramref name="zone"/> ("3d", "7h 1m"), or <c>null</c> when the period is shorter than the minimum right now (Today just after midnight).</summary>
+    public static string? CurrentLength(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
+        => spec.TryResolve(nowUtc, zone, out var range, out _) ? range!.Length : null;
+
+    /// <summary>Finds a preset (short or calendar) by <see cref="TimeRangeSpec.Id"/>, or <c>null</c>.</summary>
+    public static TimeRangeSpec? Find(string? id)
+    {
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            return null;
+        }
+
+        var wanted = id.Trim().ToLowerInvariant();
+        foreach (var spec in Rolling)
+        {
+            if (string.Equals(spec.Id, wanted, StringComparison.Ordinal))
+            {
+                return spec;
+            }
+        }
+
+        foreach (var spec in CalendarPeriods)
+        {
+            if (string.Equals(spec.Id, wanted, StringComparison.Ordinal))
+            {
+                return spec;
+            }
+        }
+
+        return null;
+    }
+
+    /// <summary>The short label on a preset button: "5m", "4h", "1d", "1w", "1mo".</summary>
+    public static string ShortLabel(TimeRangeSpec spec) => spec.Id;
+}
+
+/// <summary>
+/// The one-line notes beside the picker (#5562): where the stored data starts, and how often a tab's collector
+/// samples when the range holds too few samples to draw. Pure, so the picker, the tabs and the tests word them alike.
+/// </summary>
+public static class TimeRangeNotes
+{
+    /// <summary>How far before the data's start a range may begin before the note appears (collection stamps and the first sample's lag).</summary>
+    public static readonly TimeSpan DataStartSlack = TimeSpan.FromMinutes(90);
+
+    /// <summary>The fewest samples a range should hold before the collector-interval note appears.</summary>
+    public const int MinSamples = 3;
+
+    /// <summary>
+    /// "Data starts Oct 3, 2:00 pm" when the range starts more than <see cref="DataStartSlack"/> before
+    /// <paramref name="dataStartUtc"/>, else <c>null</c>. The time is in the range's display zone.
+    /// </summary>
+    public static string? DataStartNote(ResolvedTimeRange range, DateTime? dataStartUtc)
+    {
+        if (dataStartUtc is null)
+        {
+            return null;
+        }
+
+        var dataStart = TimeRangeSpec.Naive(dataStartUtc.Value);
+        if (range.StartUtc >= dataStart - DataStartSlack)
+        {
+            return null;
+        }
+
+        return "Data starts " + range.FormatBound(dataStart, includeSeconds: false);
+    }
+
+    /// <summary>
+    /// "Data here is collected every 5 minutes." when the range holds fewer than <see cref="MinSamples"/> samples at
+    /// <paramref name="interval"/>, else <c>null</c>. A tab names its main collector's actual interval; the note
+    /// explains an empty or one-point chart and never widens the range.
+    /// </summary>
+    public static string? SampleIntervalNote(TimeSpan span, TimeSpan? interval)
+    {
+        if (interval is null || interval.Value <= TimeSpan.Zero || span >= TimeSpan.FromTicks(interval.Value.Ticks * MinSamples))
+        {
+            return null;
+        }
+
+        return "Data here is collected every " + IntervalText(interval.Value) + ".";
+    }
+
+    /// <summary>"minute", "5 minutes", "2 hours", "30 seconds".</summary>
+    public static string IntervalText(TimeSpan interval)
+    {
+        long count;
+        string unit;
+        if (interval.Ticks % TimeSpan.TicksPerHour == 0)
+        {
+            count = (long)interval.TotalHours;
+            unit = "hour";
+        }
+        else if (interval.Ticks % TimeSpan.TicksPerMinute == 0)
+        {
+            count = (long)interval.TotalMinutes;
+            unit = "minute";
+        }
+        else
+        {
+            count = Math.Max(1, (long)Math.Round(interval.TotalSeconds));
+            unit = "second";
+        }
+
+        return count == 1 ? unit : count.ToString(CultureInfo.InvariantCulture) + " " + unit + "s";
+    }
+}
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
new file mode 100644
index 0000000000..609775da66
--- /dev/null
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
@@ -0,0 +1,461 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Globalization;
+
+namespace PerformanceMonitor.Ui;
+
+/// <summary>How a <see cref="TimeRangeSpec"/> names its range (#5562).</summary>
+public enum TimeRangeKind
+{
+    /// <summary>A length counted back from now: 45m, 4h, 10d. Real elapsed time, so a day is 24 hours across a daylight saving change.</summary>
+    Relative,
+
+    /// <summary>A calendar period in the display zone: Today, Previous Week, Year to Date. Wall-clock boundaries.</summary>
+    Calendar,
+
+    /// <summary>A start and an end instant, both fixed.</summary>
+    Fixed,
+
+    /// <summary>A fixed start and an end that slides with now ("since 10/1", "Oct 2 12pm to now").</summary>
+    Since
+}
+
+/// <summary>The calendar periods the picker offers (#5562). Weeks start on Monday.</summary>
+public enum CalendarPeriod
+{
+    /// <summary>From the last local midnight to now.</summary>
+    Today,
+
+    /// <summary>The whole local day before today.</summary>
+    Yesterday,
+
+    /// <summary>From Monday 00:00 to now.</summary>
+    WeekToDate,
+
+    /// <summary>The whole Monday-to-Sunday week before this one.</summary>
+    PreviousWeek,
+
+    /// <summary>From the first of this month to now.</summary>
+    MonthToDate,
+
+    /// <summary>The whole calendar month before this one.</summary>
+    PreviousMonth,
+
+    /// <summary>From January 1 to now.</summary>
+    YearToDate,
+
+    /// <summary>The whole calendar year before this one.</summary>
+    PreviousYear
+}
+
+/// <summary>Why a range was refused: a stable <see cref="Code"/> (the shared fixture compares it) and a plain <see cref="Message"/>.</summary>
+public sealed record TimeRangeError(string Code, string Message);
+
+/// <summary>
+/// A time range the way a person names it, not yet tied to a clock (#5562): "past 4 hours", "Previous Week",
+/// "Oct 1 to Oct 2". <see cref="TryResolve"/> turns it into the instants for a given now and display zone, so a
+/// live range slides and a calendar period follows the zone, while a fixed range keeps its instants. Pure: nothing
+/// here reads the machine's clock or zone. Every DateTime is naive UTC (Kind Unspecified), the frame the stores keep.
+///
+/// <para>Rules (settled, #5562): relative lengths are real elapsed time; calendar periods use the display zone's
+/// wall-clock boundaries, a boundary being the earliest instant labelled at or after the wall midnight, so
+/// consecutive periods tile with no gap or overlap; no range is shorter than <see cref="MinimumSpan"/>; there is no
+/// upper cap here (a tab reads what its data holds).</para>
+/// </summary>
+public sealed class TimeRangeSpec : IEquatable<TimeRangeSpec>
+{
+    /// <summary>The shortest range there is, everywhere. A shorter one is refused, never widened.</summary>
+    public static readonly TimeSpan MinimumSpan = TimeSpan.FromMinutes(5);
+
+    /// <summary>The longest relative length the model resolves; past it a count is refused as a typing slip.</summary>
+    private static readonly TimeSpan MaxRelative = TimeSpan.FromDays(36500);
+
+    private TimeRangeSpec(TimeRangeKind kind)
+    {
+        Kind = kind;
+    }
+
+    /// <summary>Which kind of range this is.</summary>
+    public TimeRangeKind Kind { get; }
+
+    /// <summary>The length, for <see cref="TimeRangeKind.Relative"/>.</summary>
+    public TimeSpan Span { get; private init; }
+
+    /// <summary>The period, for <see cref="TimeRangeKind.Calendar"/>.</summary>
+    public CalendarPeriod Period { get; private init; }
+
+    /// <summary>The start instant, for <see cref="TimeRangeKind.Fixed"/> and <see cref="TimeRangeKind.Since"/>.</summary>
+    public DateTime StartUtc { get; private init; }
+
+    /// <summary>The end instant, for <see cref="TimeRangeKind.Fixed"/>.</summary>
+    public DateTime EndUtc { get; private init; }
+
+    /// <summary>A length counted back from now.</summary>
+    public static TimeRangeSpec Relative(TimeSpan span)
+        => new(TimeRangeKind.Relative) { Span = span };
+
+    /// <summary>A calendar period in the display zone.</summary>
+    public static TimeRangeSpec ForPeriod(CalendarPeriod period)
+        => new(TimeRangeKind.Calendar) { Period = period };
+
+    /// <summary>A start and an end instant (naive UTC).</summary>
+    public static TimeRangeSpec FixedRange(DateTime startUtc, DateTime endUtc)
+        => new(TimeRangeKind.Fixed) { StartUtc = Naive(startUtc), EndUtc = Naive(endUtc) };
+
+    /// <summary>A fixed start with an end that is always now.</summary>
+    public static TimeRangeSpec SinceInstant(DateTime startUtc)
+        => new(TimeRangeKind.Since) { StartUtc = Naive(startUtc) };
+
+    /// <summary>
+    /// A stable text for settings and for telling two specs apart: "5m", "4h", "1d", "1w", "1mo", "today",
+    /// "previous-week", "fixed:2026-10-01T04:00:00Z/2026-10-02T04:00:00Z", "since:2026-10-01T04:00:00Z".
+    /// A relative length of exactly 7 days is "1w" and of exactly 30 days "1mo", whichever way it was typed.
+    /// </summary>
+    public string Id => Kind switch
+    {
+        TimeRangeKind.Relative => RelativeId(Span),
+        TimeRangeKind.Calendar => PeriodId(Period),
+        TimeRangeKind.Fixed => "fixed:" + IsoZ(StartUtc) + "/" + IsoZ(EndUtc),
+        _ => "since:" + IsoZ(StartUtc)
+    };
+
+    /// <summary>The whole hours of a relative range, or <c>null</c> when it is not a whole number of hours (or not relative). For readers that still take "hours back".</summary>
+    public int? WholeHours
+        => Kind == TimeRangeKind.Relative && Span.Ticks % TimeSpan.TicksPerHour == 0 && Span.TotalHours <= int.MaxValue
+            ? (int)Span.TotalHours
+            : null;
+
+    /// <summary>The name the picker lists: "Past 4 hours", "Previous Week"; a fixed or since range reads as a generic name.</summary>
+    public string Name => Kind switch
+    {
+        TimeRangeKind.Relative => "Past " + PastLength(Span),
+        TimeRangeKind.Calendar => PeriodName(Period),
+        TimeRangeKind.Fixed => "Custom range",
+        _ => "Since a start"
+    };
+
+    /// <summary>
+    /// The instants this range means at <paramref name="nowUtc"/> in <paramref name="zone"/>, or the reason it
+    /// cannot be used (shorter than <see cref="MinimumSpan"/>, ends before it starts, reaches back too far).
+    /// </summary>
+    public bool TryResolve(DateTime nowUtc, TimeZoneInfo zone, out ResolvedTimeRange? range, out TimeRangeError? error)
+    {
+        var now = Naive(nowUtc);
+        range = null;
+        error = null;
+        DateTime start;
+        DateTime end;
+        bool live;
+
+        switch (Kind)
+        {
+            case TimeRangeKind.Relative:
+                if (Span <= TimeSpan.Zero)
+                {
+                    error = new TimeRangeError("too_short", ShortMessage(TimeSpan.Zero));
+                    return false;
+                }
+
+                if (Span > MaxRelative)
+                {
+                    error = new TimeRangeError("too_far_back", "That reaches back more than 100 years.");
+                    return false;
+                }
+
+                start = now - Span;
+                end = now;
+                live = true;
+                break;
+
+            case TimeRangeKind.Calendar:
+                (start, end, live) = ResolvePeriod(Period, now, zone);
+                break;
+
+            case TimeRangeKind.Since:
+                start = StartUtc;
+                end = now;
+                live = true;
+                break;
+
+            default:
+                start = StartUtc;
+                end = EndUtc;
+                live = false;
+                break;
+        }
+
+        if (end < start)
+        {
+            error = Kind == TimeRangeKind.Since
+                ? new TimeRangeError("start_in_future", "That start has not happened yet.")
+                : new TimeRangeError("end_before_start", "The end is before the start.");
+            return false;
+        }
+
+        if (end - start < MinimumSpan)
+        {
+            error = new TimeRangeError("too_short", ShortMessage(end - start));
+            return false;
+        }
+
+        range = new ResolvedTimeRange(this, start, end, live, zone, now);
+        return true;
+    }
+
+    /// <summary>Reads back an <see cref="Id"/>: a preset id, a count and unit ("90m", "3d", "2w", "2mo"), "fixed:..." or "since:...". <c>false</c> for anything else.</summary>
+    public static bool TryFromId(string? id, out TimeRangeSpec? spec)
+    {
+        spec = null;
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            return false;
+        }
+
+        var text = id.Trim().ToLowerInvariant();
+        foreach (CalendarPeriod period in Enum.GetValues<CalendarPeriod>())
+        {
+            if (PeriodId(period) == text)
+            {
+                spec = ForPeriod(period);
+                return true;
+            }
+        }
+
+        if (text.StartsWith("since:", StringComparison.Ordinal))
+        {
+            if (TryIso(text.Substring(6), out var since))
+            {
+                spec = SinceInstant(since);
+                return true;
+            }
+
+            return false;
+        }
+
+        if (text.StartsWith("fixed:", StringComparison.Ordinal))
+        {
+            var parts = text.Substring(6).Split('/');
+            if (parts.Length == 2 && TryIso(parts[0], out var a) && TryIso(parts[1], out var b))
+            {
+                spec = FixedRange(a, b);
+                return true;
+            }
+
+            return false;
+        }
+
+        var unitAt = 0;
+        while (unitAt < text.Length && char.IsAsciiDigit(text[unitAt]))
+        {
+            unitAt++;
+        }
+
+        if (unitAt == 0 || unitAt == text.Length || !long.TryParse(text.AsSpan(0, unitAt), NumberStyles.None, CultureInfo.InvariantCulture, out var count) || count <= 0 || count > 1_000_000)
+        {
+            return false;
+        }
+
+        var unit = text.Substring(unitAt);
+        TimeSpan span;
+        switch (unit)
+        {
+            case "m": span = TimeSpan.FromMinutes(count); break;
+            case "h": span = TimeSpan.FromHours(count); break;
+            case "d": span = TimeSpan.FromDays(count); break;
+            case "w": span = TimeSpan.FromDays(7d * count); break;
+            case "mo": span = TimeSpan.FromDays(30d * count); break;
+            default: return false;
+        }
+
+        spec = Relative(span);
+        return true;
+    }
+
+    /// <summary>The length of a span as the picker words it: "3d" for three days and some hours, "7h 1m" under a day, "45m". Floors; a day or more drops the hours.</summary>
+    public static string FormatLength(TimeSpan span)
+    {
+        if (span < TimeSpan.Zero)
+        {
+            span = TimeSpan.Zero;
+        }
+
+        var totalMinutes = (long)Math.Floor(span.TotalMinutes);
+        if (totalMinutes >= 1440)
+        {
+            return (totalMinutes / 1440).ToString(CultureInfo.InvariantCulture) + "d";
+        }
+
+        var hours = totalMinutes / 60;
+        var minutes = totalMinutes % 60;
+        if (hours == 0)
+        {
+            return minutes.ToString(CultureInfo.InvariantCulture) + "m";
+        }
+
+        return minutes == 0
+            ? hours.ToString(CultureInfo.InvariantCulture) + "h"
+            : hours.ToString(CultureInfo.InvariantCulture) + "h " + minutes.ToString(CultureInfo.InvariantCulture) + "m";
+    }
+
+    /// <summary>The refusal text for a range shorter than the minimum.</summary>
+    internal static string ShortMessage(TimeSpan actual)
+        => actual <= TimeSpan.Zero
+            ? "The shortest range is 5 minutes."
+            : "That range is only " + FormatLength(actual) + " long. The shortest range is 5 minutes.";
+
+    internal static DateTime Naive(DateTime value)
+        => DateTime.SpecifyKind(value, DateTimeKind.Unspecified);
+
+    internal static string IsoZ(DateTime naiveUtc)
+        => naiveUtc.ToString("yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture);
+
+    private static bool TryIso(string text, out DateTime naiveUtc)
+    {
+        if (DateTime.TryParseExact(text.ToUpperInvariant(), "yyyy-MM-dd'T'HH:mm:ss'Z'", CultureInfo.InvariantCulture, DateTimeStyles.None, out var parsed))
+        {
+            naiveUtc = Naive(parsed);
+            return true;
+        }
+
+        naiveUtc = default;
+        return false;
+    }
+
+    private static string RelativeId(TimeSpan span)
+    {
+        if (span == TimeSpan.FromDays(7))
+        {
+            return "1w";
+        }
+
+        if (span == TimeSpan.FromDays(30))
+        {
+            return "1mo";
+        }
+
+        if (span.Ticks % TimeSpan.TicksPerDay == 0)
+        {
+            return ((long)span.TotalDays).ToString(CultureInfo.InvariantCulture) + "d";
+        }
+
+        if (span.Ticks % TimeSpan.TicksPerHour == 0)
+        {
+            return ((long)span.TotalHours).ToString(CultureInfo.InvariantCulture) + "h";
+        }
+
+        return ((long)Math.Round(span.TotalMinutes)).ToString(CultureInfo.InvariantCulture) + "m";
+    }
+
+    private static string PastLength(TimeSpan span)
+    {
+        if (span == TimeSpan.FromDays(7))
+        {
+            return "week";
+        }
+
+        if (span == TimeSpan.FromDays(30))
+        {
+            return "30 days";
+        }
+
+        long count;
+        string unit;
+        if (span.Ticks % TimeSpan.TicksPerDay == 0)
+        {
+            count = (long)span.TotalDays;
+            unit = "day";
+        }
+        else if (span.Ticks % TimeSpan.TicksPerHour == 0)
+        {
+            count = (long)span.TotalHours;
+            unit = "hour";
+        }
+        else
+        {
+            count = (long)Math.Round(span.TotalMinutes);
+            unit = "minute";
+        }
+
+        return count == 1 ? unit : count.ToString(CultureInfo.InvariantCulture) + " " + unit + "s";
+    }
+
+    internal static string PeriodId(CalendarPeriod period) => period switch
+    {
+        CalendarPeriod.Today => "today",
+        CalendarPeriod.Yesterday => "yesterday",
+        CalendarPeriod.WeekToDate => "week-to-date",
+        CalendarPeriod.PreviousWeek => "previous-week",
+        CalendarPeriod.MonthToDate => "month-to-date",
+        CalendarPeriod.PreviousMonth => "previous-month",
+        CalendarPeriod.YearToDate => "year-to-date",
+        _ => "previous-year"
+    };
+
+    internal static string PeriodName(CalendarPeriod period) => period switch
+    {
+        CalendarPeriod.Today => "Today",
+        CalendarPeriod.Yesterday => "Yesterday",
+        CalendarPeriod.WeekToDate => "Week to Date",
+        CalendarPeriod.PreviousWeek => "Previous Week",
+        CalendarPeriod.MonthToDate => "Month to Date",
+        CalendarPeriod.PreviousMonth => "Previous Month",
+        CalendarPeriod.YearToDate => "Year to Date",
+        _ => "Previous Year"
+    };
+
+    /// <summary>
+    /// The instants of a calendar period. A boundary is the earliest instant labelled at or after the wall midnight
+    /// (<see cref="BoundSide.From"/>), so the end of one period is exactly the start of the next. The to-date
+    /// periods and Today end at now and are live; the previous periods end at the next boundary and are not.
+    /// </summary>
+    private static (DateTime Start, DateTime End, bool Live) ResolvePeriod(CalendarPeriod period, DateTime now, TimeZoneInfo zone)
+    {
+        var today = DisplayZone.ToDisplay(now, zone).Date;
+        var monday = today.AddDays(-(((int)today.DayOfWeek + 6) % 7));
+        var firstOfMonth = new DateTime(today.Year, today.Month, 1, 0, 0, 0, DateTimeKind.Unspecified);
+        var firstOfYear = new DateTime(today.Year, 1, 1, 0, 0, 0, DateTimeKind.Unspecified);
+
+        switch (period)
+        {
+            case CalendarPeriod.Today:
+                return (Boundary(today, zone), now, true);
+            case CalendarPeriod.Yesterday:
+                return (Boundary(today.AddDays(-1), zone), Boundary(today, zone), false);
+            case CalendarPeriod.WeekToDate:
+                return (Boundary(monday, zone), now, true);
+            case CalendarPeriod.PreviousWeek:
+                return (Boundary(monday.AddDays(-7), zone), Boundary(monday, zone), false);
+            case CalendarPeriod.MonthToDate:
+                return (Boundary(firstOfMonth, zone), now, true);
+            case CalendarPeriod.PreviousMonth:
+                return (Boundary(firstOfMonth.AddMonths(-1), zone), Boundary(firstOfMonth, zone), false);
+            case CalendarPeriod.YearToDate:
+                return (Boundary(firstOfYear, zone), now, true);
+            default:
+                return (Boundary(firstOfYear.AddYears(-1), zone), Boundary(firstOfYear, zone), false);
+        }
+    }
+
+    private static DateTime Boundary(DateTime wallMidnight, TimeZoneInfo zone)
+        => DisplayZone.ToUtcBound(wallMidnight, zone, BoundSide.From);
+
+    /// <inheritdoc/>
+    public bool Equals(TimeRangeSpec? other)
+        => other is not null && string.Equals(Id, other.Id, StringComparison.Ordinal);
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj) => Equals(obj as TimeRangeSpec);
+
+    /// <inheritdoc/>
+    public override int GetHashCode() => StringComparer.Ordinal.GetHashCode(Id);
+
+    /// <inheritdoc/>
+    public override string ToString() => Id;
+}

From 3a8eb280dff849be6e8d2ad358516924ca84d0c4 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:18:05 -0400
Subject: [PATCH 02/33] Shared WPF time range picker control, STA tests, UTC
 offsets allowed by the fleet-name guard (#5562)

---
 .../FleetIdentifierScrubTests.cs              |   2 +
 .../TimeRangePickerControlTests.cs            | 213 ++++++++
 Darling/Darling.Tests/TimeRangeTests.cs       |   4 +-
 Lite.Tests/Lite.Tests.csproj                  |   3 -
 PerformanceMonitor.Ui/TimeRangePicker.xaml    | 109 ++++
 PerformanceMonitor.Ui/TimeRangePicker.xaml.cs | 511 ++++++++++++++++++
 6 files changed, 837 insertions(+), 5 deletions(-)
 create mode 100644 Darling/Darling.Tests/TimeRangePickerControlTests.cs
 create mode 100644 PerformanceMonitor.Ui/TimeRangePicker.xaml
 create mode 100644 PerformanceMonitor.Ui/TimeRangePicker.xaml.cs

diff --git a/Darling/Darling.Tests/FleetIdentifierScrubTests.cs b/Darling/Darling.Tests/FleetIdentifierScrubTests.cs
index 43d34e4b07..4207ee9f78 100644
--- a/Darling/Darling.Tests/FleetIdentifierScrubTests.cs
+++ b/Darling/Darling.Tests/FleetIdentifierScrubTests.cs
@@ -80,6 +80,8 @@ fleet has a pg-* store as well as use[0-9] ones.
     private static readonly HashSet<string> OrdinalRoleWords = new(StringComparer.OrdinalIgnoreCase)
     {
         "prod", "dev", "local", "sql", "aurora", "srv", "box", "web", "target", "bench", "gone",
+        // A zone offset in the time range picker's label and tests ("UTC-04:00", #5562): a clock offset, never a tenant.
+        "utc",
     };
 
     /*
diff --git a/Darling/Darling.Tests/TimeRangePickerControlTests.cs b/Darling/Darling.Tests/TimeRangePickerControlTests.cs
new file mode 100644
index 0000000000..85d6a46351
--- /dev/null
+++ b/Darling/Darling.Tests/TimeRangePickerControlTests.cs
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Threading;
+using System.Windows;
+using System.Windows.Media;
+using System.Windows.Threading;
+using PerformanceMonitor.Ui;
+using Xunit;
+
+/* Darling.Tests only: a Darling file Lite.Tests compiles must be named in build.yml's Lite path filter. */
+namespace Darling.Tests;
+
+/// <summary>#5562: the shared WPF time range picker constructs, renders and raises its event on an STA thread.</summary>
+public sealed class TimeRangePickerControlTests
+{
+    private static readonly TimeZoneInfo NewYork = TimeZoneInfo.FindSystemTimeZoneById("America/New_York");
+    private static readonly DateTime Now = new(2026, 10, 8, 11, 1, 0, DateTimeKind.Unspecified);
+
+    private static TimeRangePicker Build()
+        => new() { ZoneProvider = () => NewYork, NowProvider = () => Now };
+
+    [Fact]
+    public void Constructs_WithTheShortPresetsAndTheCalendarPeriods()
+    {
+        OnStaThread(() =>
+        {
+            var picker = Build();
+            Assert.Equal(9, picker.RollingPanel.Children.Count);
+            Assert.Equal(8, picker.PeriodPanel.Children.Count);
+            Assert.Equal("4h", picker.Value.Id);
+            Assert.Equal("Past 4 hours", picker.ButtonText.Text);
+            Assert.Equal("Oct 8, 3:01 am - Oct 8, 7:01 am (UTC-04:00)", picker.ResolvedText.Text);
+            Assert.False(picker.IsPopupOpen);
+        });
+    }
+
+    [Fact]
+    public void Value_RendersWithoutRaisingTheEvent_AndSelectRaisesIt()
+    {
+        OnStaThread(() =>
+        {
+            var picker = Build();
+            var raised = 0;
+            TimeRangeChangedEventArgs? last = null;
+            picker.RangeChanged += (_, e) => { raised++; last = e; };
+
+            picker.Value = TimeRangeSpec.ForPeriod(CalendarPeriod.WeekToDate);
+            Assert.Equal(0, raised);
+            Assert.Equal("Week to Date", picker.ButtonText.Text);
+            Assert.Equal("Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)", picker.ResolvedText.Text);
+
+            Assert.True(picker.Select(TimeRangePresets.Find("1w")!));
+            Assert.Equal(1, raised);
+            Assert.Equal("1w", last!.Spec.Id);
+            Assert.Equal(TimeSpan.FromDays(7), last.Range.Span);
+            Assert.Equal("1w", picker.Value.Id);
+        });
+    }
+
+    [Fact]
+    public void Select_RefusesARangeUnderTheMinimum_AndHoldsTheOldOne()
+    {
+        OnStaThread(() =>
+        {
+            var picker = Build();
+            picker.NowProvider = () => new DateTime(2026, 10, 8, 4, 2, 0, DateTimeKind.Unspecified);
+            var raised = false;
+            picker.RangeChanged += (_, _) => raised = true;
+
+            Assert.False(picker.Select(TimeRangeSpec.ForPeriod(CalendarPeriod.Today)));
+            Assert.False(raised);
+            Assert.Equal("4h", picker.Value.Id);
+        });
+    }
+
+    [Fact]
+    public void Resolve_FollowsTheZoneProvider()
+    {
+        OnStaThread(() =>
+        {
+            var picker = Build();
+            picker.Value = TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday);
+            var eastern = picker.Resolve()!;
+            picker.ZoneProvider = () => TimeZoneInfo.Utc;
+            picker.Refresh();
+            var utc = picker.Resolve()!;
+            Assert.NotEqual(eastern.StartUtc, utc.StartUtc);
+            Assert.Equal("Oct 7, 12:00 am - Oct 8, 12:00 am (UTC+00:00)", picker.ResolvedText.Text);
+        });
+    }
+
+    [Fact]
+    public void Notes_ShowTheDataStartAndTheCollectorInterval()
+    {
+        OnStaThread(() =>
+        {
+            var picker = Build();
+            picker.Value = TimeRangePresets.Find("1w")!;
+            Assert.Equal(Visibility.Collapsed, picker.NoteText.Visibility);
+
+            picker.DataStartUtc = new DateTime(2026, 10, 3, 18, 0, 0);
+            Assert.Equal(Visibility.Visible, picker.NoteText.Visibility);
+            Assert.Equal("Data starts Oct 3, 2:00 pm", picker.NoteText.Text);
+
+            picker.Value = TimeRangePresets.Find("5m")!;
+            picker.DataStartUtc = null;
+            picker.SampleInterval = TimeSpan.FromMinutes(5);
+            Assert.Equal("Data here is collected every 5 minutes.", picker.NoteText.Text);
+
+            picker.SampleInterval = TimeSpan.FromMinutes(1);
+            Assert.Equal(Visibility.Collapsed, picker.NoteText.Visibility);
+        });
+    }
+
+    [Fact]
+    public void Compact_HidesTheDetailBesideTheButton_AndKeepsItInTheTooltip()
+    {
+        OnStaThread(() =>
+        {
+            var picker = Build();
+            picker.Compact = true;
+            Assert.Equal(Visibility.Collapsed, picker.DetailPanel.Visibility);
+            Assert.Contains("(UTC-04:00)", (string)picker.PickerButton.ToolTip, StringComparison.Ordinal);
+            picker.Compact = false;
+            Assert.Equal(Visibility.Visible, picker.DetailPanel.Visibility);
+        });
+    }
+
+    [Fact]
+    public void TypingARange_PreviewsItBeforeApply_AndAnErrorDisablesApply()
+    {
+        OnStaThread(() =>
+        {
+            var picker = Build();
+            picker.InputBox.Text = "last month";
+            Assert.True(picker.ApplyButton.IsEnabled);
+            Assert.Equal("30d  Sep 1, 12:00 am - Oct 1, 12:00 am (UTC-04:00)", picker.EchoText.Text);
+
+            picker.InputBox.Text = "3m";
+            Assert.False(picker.ApplyButton.IsEnabled);
+            Assert.Contains("5 minutes", picker.EchoText.Text, StringComparison.Ordinal);
+        });
+    }
+
+    [Fact]
+    public void OpeningThePopup_ThemesTheCalendarFromTheHostBrushes_AndAPickedRangeFillsTheTextBox()
+    {
+        OnStaThread(() =>
+        {
+            var dark = new SolidColorBrush(Color.FromRgb(0x11, 0x12, 0x17));
+            var light = new SolidColorBrush(Color.FromRgb(0xE4, 0xE6, 0xEB));
+            var picker = Build();
+            picker.Resources["BackgroundBrush"] = dark;
+            picker.Resources["ForegroundBrush"] = light;
+            var window = new Window { Content = picker, Width = 300, Height = 200, ShowActivated = false, WindowStyle = WindowStyle.None, ShowInTaskbar = false, Left = -4000, Top = -4000 };
+            try
+            {
+                window.Show();
+                picker.PickerPopup.IsOpen = true;
+                // Let the Opened handler and its Loaded-priority theming pass run.
+                window.Dispatcher.Invoke(() => { }, DispatcherPriority.ApplicationIdle);
+
+                Assert.Same(dark, picker.PickCalendar.Background);
+                Assert.Same(light, picker.PickCalendar.Foreground);
+                Assert.Equal("Examples:", picker.EchoText.Text.Substring(0, 9));
+                Assert.NotEmpty(picker.PeriodPanel.Children);
+
+                picker.PickCalendar.SelectedDates.AddRange(new DateTime(2026, 10, 1), new DateTime(2026, 10, 3));
+                Assert.Equal("Oct 1 - Oct 3", picker.InputBox.Text);
+                Assert.True(picker.ApplyButton.IsEnabled);
+
+                TimeRangeChangedEventArgs? picked = null;
+                picker.RangeChanged += (_, e) => picked = e;
+                picker.ApplyButton.RaiseEvent(new RoutedEventArgs(System.Windows.Controls.Primitives.ButtonBase.ClickEvent));
+                Assert.NotNull(picked);
+                Assert.Equal(TimeRangeKind.Fixed, picked!.Spec.Kind);
+                Assert.Equal(new DateTime(2026, 10, 1, 4, 0, 0), picked.Range.StartUtc);
+                Assert.Equal(new DateTime(2026, 10, 4, 4, 0, 0), picked.Range.EndUtc);
+                Assert.False(picker.IsPopupOpen);
+            }
+            finally
+            {
+                window.Close();
+            }
+        });
+    }
+
+    /// <summary>WPF objects require STA; same shape as AvailabilityGroupsTabRefreshTests.</summary>
+    private static void OnStaThread(Action body)
+    {
+        Exception? error = null;
+        var thread = new Thread(() =>
+        {
+            try { body(); }
+            catch (Exception ex) { error = ex; }
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (error is not null)
+        {
+            throw error;
+        }
+    }
+}
diff --git a/Darling/Darling.Tests/TimeRangeTests.cs b/Darling/Darling.Tests/TimeRangeTests.cs
index 40a3c372d0..c329f21dd6 100644
--- a/Darling/Darling.Tests/TimeRangeTests.cs
+++ b/Darling/Darling.Tests/TimeRangeTests.cs
@@ -15,8 +15,8 @@
 using PerformanceMonitor.Ui;
 using Xunit;
 
-/* This file is compiled into Darling.Tests and Lite.Tests (a linked Compile item), so both test assemblies pin the
-   shared picker model; the namespace is the same in each. */
+/* Darling.Tests covers the shared picker model (Lite and the Viewer both reference PerformanceMonitor.Ui).
+   Lite.Tests does not compile this file: a linked Darling file must be named in build.yml's Lite path filter. */
 namespace Darling.Tests;
 
 /// <summary>
diff --git a/Lite.Tests/Lite.Tests.csproj b/Lite.Tests/Lite.Tests.csproj
index b393361c01..6753fc6ed0 100644
--- a/Lite.Tests/Lite.Tests.csproj
+++ b/Lite.Tests/Lite.Tests.csproj
@@ -61,9 +61,6 @@
     <!-- system_health event samples (one per feeder event; shapes per sp_HealthParser xpath) for the
          System Events reader round-trip tests. Mirrors Darling.Tests' Fixtures\SystemHealth set. -->
     <None Include="Fixtures\SystemHealth\*.xml" CopyToOutputDirectory="PreserveNewest" />
-    <!-- The shared time range cases and tests (#5562): one file each, linked from Darling.Tests so both assemblies run the same grammar. -->
-    <None Include="..\Darling\Darling.Tests\Fixtures\time-range-cases.json" Link="Fixtures\time-range-cases.json" CopyToOutputDirectory="PreserveNewest" />
-    <Compile Include="..\Darling\Darling.Tests\TimeRangeTests.cs" Link="TimeRangeTests.cs" />
     <!-- Lite's MCP host source, copied beside the test binary (it lives outside this project directory, so the
          default Compile glob never sees it) so HostHeaderGuardTests can pin that the #1648 DNS-rebinding
          middleware is installed FIRST, ahead of MapMcp. Mirrors Darling.Tests' guard on its two hosts — the
diff --git a/PerformanceMonitor.Ui/TimeRangePicker.xaml b/PerformanceMonitor.Ui/TimeRangePicker.xaml
new file mode 100644
index 0000000000..2d7716003d
--- /dev/null
+++ b/PerformanceMonitor.Ui/TimeRangePicker.xaml
@@ -0,0 +1,109 @@
+<UserControl x:Class="PerformanceMonitor.Ui.TimeRangePicker"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Name="Root"
+             Focusable="False">
+    <!--
+      Shared time range picker (#5562): a button naming the range, the resolved start, end and zone beside it, and a
+      popup with the short presets, the calendar periods, a text box that previews what it parsed before Apply, and a
+      calendar for picking a range. Themed through the shared brush keys (Background, Foreground, Border, Accent...)
+      that both apps' Dark, Light and Cool Breeze dictionaries define, so it follows the theme with no code.
+    -->
+    <StackPanel Orientation="Horizontal" VerticalAlignment="Center">
+        <Button x:Name="PickerButton"
+                Click="PickerButton_Click"
+                Padding="10,4"
+                MinHeight="26"
+                HorizontalContentAlignment="Left"
+                AutomationProperties.Name="Time range">
+            <StackPanel Orientation="Horizontal">
+                <TextBlock x:Name="ButtonText" VerticalAlignment="Center"/>
+                <TextBlock Text="&#x25BE;" Margin="8,0,0,0" VerticalAlignment="Center"
+                           Foreground="{DynamicResource ForegroundDimBrush}"/>
+            </StackPanel>
+        </Button>
+
+        <StackPanel x:Name="DetailPanel" Margin="10,0,0,0" VerticalAlignment="Center">
+            <TextBlock x:Name="ResolvedText"
+                       Foreground="{DynamicResource ForegroundDimBrush}"
+                       VerticalAlignment="Center"
+                       AutomationProperties.Name="Resolved time range"/>
+            <TextBlock x:Name="NoteText"
+                       Foreground="{DynamicResource WarningTextBrush}"
+                       FontSize="11"
+                       Visibility="Collapsed"
+                       TextWrapping="Wrap"
+                       MaxWidth="460"/>
+        </StackPanel>
+
+        <Popup x:Name="PickerPopup"
+               PlacementTarget="{Binding ElementName=PickerButton}"
+               Placement="Bottom"
+               StaysOpen="False"
+               AllowsTransparency="True"
+               PopupAnimation="Fade"
+               Opened="PickerPopup_Opened"
+               Closed="PickerPopup_Closed">
+            <Border Background="{DynamicResource BackgroundBrush}"
+                    BorderBrush="{DynamicResource BorderBrush}"
+                    BorderThickness="1"
+                    CornerRadius="6"
+                    Padding="10"
+                    Margin="0,2,8,8"
+                    PreviewKeyDown="PopupRoot_PreviewKeyDown"
+                    TextElement.Foreground="{DynamicResource ForegroundBrush}"
+                    TextElement.FontFamily="Segoe UI">
+                <Border.Effect>
+                    <DropShadowEffect BlurRadius="10" ShadowDepth="2" Opacity="0.35"/>
+                </Border.Effect>
+                <Grid>
+                    <Grid.ColumnDefinitions>
+                        <ColumnDefinition Width="Auto"/>
+                        <ColumnDefinition Width="12"/>
+                        <ColumnDefinition Width="Auto"/>
+                    </Grid.ColumnDefinitions>
+
+                    <!-- Left: the presets. -->
+                    <StackPanel Grid.Column="0" Width="196">
+                        <TextBlock Text="Past" FontWeight="SemiBold" Margin="0,0,0,4"
+                                   Foreground="{DynamicResource ForegroundDimBrush}"/>
+                        <WrapPanel x:Name="RollingPanel"/>
+                        <TextBlock Text="Calendar" FontWeight="SemiBold" Margin="0,10,0,4"
+                                   Foreground="{DynamicResource ForegroundDimBrush}"/>
+                        <StackPanel x:Name="PeriodPanel"/>
+                    </StackPanel>
+
+                    <!-- Right: type a range, see what it parsed, or pick days on the calendar. -->
+                    <StackPanel Grid.Column="2" Width="300">
+                        <TextBlock Text="Type a range" FontWeight="SemiBold" Margin="0,0,0,4"
+                                   Foreground="{DynamicResource ForegroundDimBrush}"/>
+                        <TextBox x:Name="InputBox"
+                                 Padding="6,4"
+                                 TextChanged="InputBox_TextChanged"
+                                 KeyDown="InputBox_KeyDown"
+                                 AutomationProperties.Name="Type a time range"
+                                 ToolTip="45m, 3 days, last month, Oct 1 - Oct 2, 1:00 am - 7:00 am, since 10/1, 1790852543 - 1791457343"/>
+                        <TextBlock x:Name="EchoText"
+                                   Margin="0,6,0,0"
+                                   MinHeight="34"
+                                   TextWrapping="Wrap"
+                                   Foreground="{DynamicResource ForegroundDimBrush}"/>
+                        <Calendar x:Name="PickCalendar"
+                                  Margin="0,6,0,0"
+                                  HorizontalAlignment="Left"
+                                  SelectionMode="SingleRange"
+                                  FirstDayOfWeek="Monday"
+                                  SelectedDatesChanged="PickCalendar_SelectedDatesChanged"
+                                  AutomationProperties.Name="Pick days on a calendar"/>
+                        <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,8,0,0">
+                            <Button x:Name="CancelButton" Content="Cancel" Padding="12,4" Margin="0,0,6,0" Click="CancelButton_Click"/>
+                            <Button x:Name="ApplyButton" Content="Apply" Padding="14,4" IsEnabled="False" Click="ApplyButton_Click"
+                                    Background="{DynamicResource AccentBrush}"
+                                    Foreground="{DynamicResource AccentForegroundBrush}"/>
+                        </StackPanel>
+                    </StackPanel>
+                </Grid>
+            </Border>
+        </Popup>
+    </StackPanel>
+</UserControl>
diff --git a/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs b/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
new file mode 100644
index 0000000000..9e38f76a0e
--- /dev/null
+++ b/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
@@ -0,0 +1,511 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Windows;
+using System.Windows.Automation;
+using System.Windows.Controls;
+using System.Windows.Controls.Primitives;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+namespace PerformanceMonitor.Ui;
+
+/// <summary>Raised when the user picks a range (<see cref="TimeRangePicker.RangeChanged"/>).</summary>
+public sealed class TimeRangeChangedEventArgs : EventArgs
+{
+    /// <summary>Wraps the new range.</summary>
+    public TimeRangeChangedEventArgs(TimeRangeSpec spec, ResolvedTimeRange range)
+    {
+        Spec = spec;
+        Range = range;
+    }
+
+    /// <summary>The range as named; hold this to keep it live, or persist its <see cref="TimeRangeSpec.Id"/>.</summary>
+    public TimeRangeSpec Spec { get; }
+
+    /// <summary>The range at the moment it was picked.</summary>
+    public ResolvedTimeRange Range { get; }
+}
+
+/// <summary>
+/// The shared time range picker (#5562) for Lite and the Darling Viewer: a button naming the range, the resolved
+/// start, end and zone beside it, and a popup with the short presets, the calendar periods (each with its current
+/// length), a text box that shows what it parsed before Apply (or why it failed), and a calendar for picking days.
+/// A tab sets <see cref="ZoneProvider"/> to its display zone and handles <see cref="RangeChanged"/>; on every
+/// refresh it calls <see cref="Resolve"/> for the window to read, so a live range keeps sliding.
+///
+/// <para>Themed through the shared brush keys (BackgroundBrush, ForegroundBrush, BorderBrush, AccentBrush...) that both
+/// apps' dictionaries define. Enter applies the typed range, Esc closes the popup. UI thread only.</para>
+/// </summary>
+public partial class TimeRangePicker : UserControl
+{
+    private static readonly TimeSpan ReopenGuard = TimeSpan.FromMilliseconds(250);
+
+    private readonly List<(Button Button, TimeRangeSpec Spec)> _rollingButtons = new();
+    private readonly List<(Button Button, TimeRangeSpec Spec, TextBlock Length)> _periodButtons = new();
+    private TimeRangeSpec _value = TimeRangePresets.Rolling[4];
+    private DateTime? _dataStartUtc;
+    private TimeSpan? _sampleInterval;
+    private bool _compact;
+    private long _closedAtTick;
+    private TimeRangeParseResult? _typed;
+    private Func<TimeZoneInfo>? _zoneProvider;
+    private Func<DateTime>? _nowProvider;
+
+    /// <summary>Builds the picker with the default range (4h).</summary>
+    public TimeRangePicker()
+    {
+        InitializeComponent();
+        BuildPresetButtons();
+        PickCalendar.GotMouseCapture += (_, e) =>
+        {
+            /* A Calendar in a popup keeps the mouse captured after a day click and swallows the next click. */
+            if (e.OriginalSource is CalendarItem or CalendarDayButton or CalendarButton)
+            {
+                ((UIElement)e.OriginalSource).ReleaseMouseCapture();
+            }
+        };
+        Refresh();
+    }
+
+    /// <summary>Raised when the user picks a range by preset, period, typed text or calendar. Not raised by <see cref="Value"/>.</summary>
+    public event EventHandler<TimeRangeChangedEventArgs>? RangeChanged;
+
+    /// <summary>The display zone for typed times, calendar periods and the shown text; the tab's own zone. Default is this machine's zone.</summary>
+    public Func<TimeZoneInfo>? ZoneProvider
+    {
+        get => _zoneProvider;
+        set
+        {
+            _zoneProvider = value;
+            Refresh();
+        }
+    }
+
+    /// <summary>The clock as naive UTC; default is the machine clock. Tests set it.</summary>
+    public Func<DateTime>? NowProvider
+    {
+        get => _nowProvider;
+        set
+        {
+            _nowProvider = value;
+            Refresh();
+        }
+    }
+
+    /// <summary>The zone in force now.</summary>
+    public TimeZoneInfo Zone => ZoneProvider?.Invoke() ?? TimeZoneInfo.Local;
+
+    /// <summary>The range held. Setting it re-renders the picker and does not raise <see cref="RangeChanged"/>.</summary>
+    public TimeRangeSpec Value
+    {
+        get => _value;
+        set
+        {
+            _value = value ?? TimeRangePresets.Rolling[4];
+            Refresh();
+        }
+    }
+
+    /// <summary>
+    /// Where the tab's stored data starts, if known (naive UTC). When the range starts more than 90 minutes earlier
+    /// the picker adds "Data starts Oct 3, 2:00 pm" beside the resolved range.
+    /// </summary>
+    public DateTime? DataStartUtc
+    {
+        get => _dataStartUtc;
+        set
+        {
+            _dataStartUtc = value;
+            Refresh();
+        }
+    }
+
+    /// <summary>
+    /// How often the tab's main collector samples (its actual interval). When the range holds fewer than 3 samples
+    /// the picker adds "Data here is collected every N minutes." so a short or empty chart has a reason. Null for none.
+    /// </summary>
+    public TimeSpan? SampleInterval
+    {
+        get => _sampleInterval;
+        set
+        {
+            _sampleInterval = value;
+            Refresh();
+        }
+    }
+
+    /// <summary>True for a one-button form (FinOps): the resolved range and notes move to the button's tooltip.</summary>
+    public bool Compact
+    {
+        get => _compact;
+        set
+        {
+            _compact = value;
+            PickerButton.Padding = value ? new Thickness(8, 2, 8, 2) : new Thickness(10, 4, 10, 4);
+            PickerButton.MinHeight = value ? 22 : 26;
+            Refresh();
+        }
+    }
+
+    /// <summary>True while the popup is open.</summary>
+    public bool IsPopupOpen => PickerPopup.IsOpen;
+
+    /// <summary>The held range at this moment, or <c>null</c> when it cannot be used right now (Today in its first minutes).</summary>
+    public ResolvedTimeRange? Resolve()
+        => _value.TryResolve(NowUtc, Zone, out var range, out _) ? range : null;
+
+    /// <summary>Holds <paramref name="spec"/> and raises <see cref="RangeChanged"/>, as if the user picked it. <c>false</c> (nothing held) when it cannot be resolved now.</summary>
+    public bool Select(TimeRangeSpec spec)
+    {
+        ArgumentNullException.ThrowIfNull(spec);
+        if (!spec.TryResolve(NowUtc, Zone, out var range, out _))
+        {
+            return false;
+        }
+
+        _value = spec;
+        Refresh();
+        RangeChanged?.Invoke(this, new TimeRangeChangedEventArgs(spec, range!));
+        return true;
+    }
+
+    /// <summary>Redraws the button, the resolved text and the notes: call it when the zone, the clock tick of a live range, <see cref="DataStartUtc"/> or <see cref="SampleInterval"/> changes.</summary>
+    public void Refresh()
+    {
+        DetailPanel.Visibility = _compact ? Visibility.Collapsed : Visibility.Visible;
+        if (!_value.TryResolve(NowUtc, Zone, out var range, out var error))
+        {
+            ButtonText.Text = _value.Name;
+            ResolvedText.Text = error!.Message;
+            NoteText.Visibility = Visibility.Collapsed;
+            PickerButton.ToolTip = error.Message;
+            return;
+        }
+
+        ButtonText.Text = ButtonLabel(range!);
+        ResolvedText.Text = range!.StartText + " - " + range.EndText + " (" + range.ZoneText + ")";
+        var notes = NotesFor(range);
+        NoteText.Text = notes;
+        NoteText.Visibility = notes.Length == 0 || _compact ? Visibility.Collapsed : Visibility.Visible;
+        PickerButton.ToolTip = notes.Length == 0 ? range.Label : range.Label + "\n" + notes;
+        UpdateSelectionMarks();
+    }
+
+    private DateTime NowUtc => TimeRangeSpec.Naive(NowProvider?.Invoke() ?? DateTime.UtcNow);
+
+    private static string ButtonLabel(ResolvedTimeRange range) => range.Spec.Kind switch
+    {
+        TimeRangeKind.Fixed => "Custom (" + range.Length + ")",
+        TimeRangeKind.Since => "Since " + range.StartText,
+        _ => range.Spec.Name
+    };
+
+    private string NotesFor(ResolvedTimeRange range)
+    {
+        var notes = new List<string>(2);
+        var dataStart = TimeRangeNotes.DataStartNote(range, _dataStartUtc);
+        if (dataStart is not null)
+        {
+            notes.Add(dataStart);
+        }
+
+        var sample = TimeRangeNotes.SampleIntervalNote(range.Span, _sampleInterval);
+        if (sample is not null)
+        {
+            notes.Add(sample);
+        }
+
+        return string.Join("  ", notes);
+    }
+
+    private void BuildPresetButtons()
+    {
+        foreach (var spec in TimeRangePresets.Rolling)
+        {
+            var button = new Button
+            {
+                Content = TimeRangePresets.ShortLabel(spec),
+                ToolTip = spec.Name,
+                MinWidth = 40,
+                Padding = new Thickness(6, 3, 6, 3),
+                Margin = new Thickness(0, 0, 4, 4),
+                Tag = spec
+            };
+            AutomationProperties.SetName(button, spec.Name);
+            button.Click += Preset_Click;
+            RollingPanel.Children.Add(button);
+            _rollingButtons.Add((button, spec));
+        }
+
+        foreach (var spec in TimeRangePresets.CalendarPeriods)
+        {
+            var length = new TextBlock { HorizontalAlignment = HorizontalAlignment.Right, VerticalAlignment = VerticalAlignment.Center };
+            length.SetResourceReference(TextBlock.ForegroundProperty, "ForegroundDimBrush");
+            var row = new Grid();
+            row.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
+            row.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });
+            row.Children.Add(new TextBlock { Text = spec.Name, VerticalAlignment = VerticalAlignment.Center });
+            Grid.SetColumn(length, 1);
+            row.Children.Add(length);
+            var button = new Button
+            {
+                Content = row,
+                HorizontalContentAlignment = HorizontalAlignment.Stretch,
+                Padding = new Thickness(8, 3, 8, 3),
+                Margin = new Thickness(0, 0, 0, 2),
+                Tag = spec
+            };
+            AutomationProperties.SetName(button, spec.Name);
+            button.Click += Preset_Click;
+            PeriodPanel.Children.Add(button);
+            _periodButtons.Add((button, spec, length));
+        }
+    }
+
+    /// <summary>Fills each period's current length ("3d") from the clock and zone, and greys one that is under the minimum right now.</summary>
+    private void RefreshPeriodLengths()
+    {
+        var now = NowUtc;
+        var zone = Zone;
+        foreach (var (button, spec, length) in _periodButtons)
+        {
+            var text = TimeRangePresets.CurrentLength(spec, now, zone);
+            length.Text = text ?? string.Empty;
+            button.IsEnabled = text is not null;
+            button.ToolTip = text is null ? spec.Name + " has only just started; the shortest range is 5 minutes." : spec.Name;
+        }
+    }
+
+    private void UpdateSelectionMarks()
+    {
+        foreach (var (button, spec) in _rollingButtons)
+        {
+            Mark(button, spec);
+        }
+
+        foreach (var (button, spec, _) in _periodButtons)
+        {
+            Mark(button, spec);
+        }
+    }
+
+    private void Mark(Button button, TimeRangeSpec spec)
+    {
+        var selected = spec.Equals(_value);
+        button.FontWeight = selected ? FontWeights.Bold : FontWeights.Normal;
+        if (selected)
+        {
+            button.SetResourceReference(Control.BorderBrushProperty, "AccentBrush");
+        }
+        else
+        {
+            button.ClearValue(Control.BorderBrushProperty);
+        }
+    }
+
+    private void PickerButton_Click(object sender, RoutedEventArgs e)
+    {
+        if (PickerPopup.IsOpen)
+        {
+            PickerPopup.IsOpen = false;
+            return;
+        }
+
+        /* The click that dismissed the popup (StaysOpen=False closes it on mouse down) arrives here as a Click too. */
+        if (Environment.TickCount64 - _closedAtTick < ReopenGuard.TotalMilliseconds)
+        {
+            return;
+        }
+
+        PickerPopup.IsOpen = true;
+    }
+
+    private void PickerPopup_Opened(object? sender, EventArgs e)
+    {
+        RefreshPeriodLengths();
+        UpdateSelectionMarks();
+        var wallNow = DisplayZone.ToDisplay(NowUtc, Zone);
+        PickCalendar.DisplayDateEnd = wallNow.Date;
+        PickCalendar.SelectedDates.Clear();
+        PickCalendar.DisplayDate = Resolve() is { } held ? DisplayZone.ToDisplay(held.StartUtc, Zone).Date : wallNow.Date;
+        InputBox.Clear();
+        UpdateEcho();
+        InputBox.Focus();
+        Dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(ApplyCalendarTheme));
+    }
+
+    private void PickerPopup_Closed(object? sender, EventArgs e)
+    {
+        _closedAtTick = Environment.TickCount64;
+    }
+
+    private void Preset_Click(object sender, RoutedEventArgs e)
+    {
+        if (sender is Button { Tag: TimeRangeSpec spec })
+        {
+            Apply(spec);
+        }
+    }
+
+    private void Apply(TimeRangeSpec spec)
+    {
+        if (Select(spec))
+        {
+            PickerPopup.IsOpen = false;
+        }
+    }
+
+    private void InputBox_TextChanged(object sender, TextChangedEventArgs e) => UpdateEcho();
+
+    private void InputBox_KeyDown(object sender, KeyEventArgs e)
+    {
+        if (e.Key == Key.Enter)
+        {
+            ApplyTyped();
+            e.Handled = true;
+        }
+    }
+
+    private void ApplyButton_Click(object sender, RoutedEventArgs e) => ApplyTyped();
+
+    private void CancelButton_Click(object sender, RoutedEventArgs e) => PickerPopup.IsOpen = false;
+
+    private void PopupRoot_PreviewKeyDown(object sender, KeyEventArgs e)
+    {
+        if (e.Key == Key.Escape)
+        {
+            PickerPopup.IsOpen = false;
+            e.Handled = true;
+        }
+    }
+
+    private void ApplyTyped()
+    {
+        if (_typed is { Ok: true, Spec: { } spec })
+        {
+            Apply(spec);
+        }
+    }
+
+    /// <summary>Parses the text box and shows the resolved range (and any notes) before Apply, or the reason it failed.</summary>
+    private void UpdateEcho()
+    {
+        var text = InputBox.Text;
+        if (string.IsNullOrWhiteSpace(text))
+        {
+            _typed = null;
+            ApplyButton.IsEnabled = false;
+            EchoText.Text = "Examples: 45m, 3 days, last month, Oct 1 - Oct 2, 1:00 am - 7:00 am, since 10/1";
+            EchoText.SetResourceReference(TextBlock.ForegroundProperty, "ForegroundDimBrush");
+            return;
+        }
+
+        _typed = TimeRangeParser.Parse(text, NowUtc, Zone);
+        if (_typed.Ok)
+        {
+            var notes = NotesFor(_typed.Range!);
+            EchoText.Text = notes.Length == 0 ? _typed.Echo : _typed.Echo + "\n" + notes;
+            EchoText.SetResourceReference(TextBlock.ForegroundProperty, "ForegroundBrush");
+            ApplyButton.IsEnabled = true;
+        }
+        else
+        {
+            EchoText.Text = _typed.Error;
+            EchoText.SetResourceReference(TextBlock.ForegroundProperty, "ErrorBrush");
+            ApplyButton.IsEnabled = false;
+        }
+    }
+
+    private void PickCalendar_SelectedDatesChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (PickCalendar.SelectedDates.Count == 0)
+        {
+            return;
+        }
+
+        var first = PickCalendar.SelectedDates.Min();
+        var last = PickCalendar.SelectedDates.Max();
+        var thisYear = DisplayZone.ToDisplay(NowUtc, Zone).Year;
+        var showYear = first.Year != thisYear || last.Year != thisYear;
+        var format = showYear ? "MMM d, yyyy" : "MMM d";
+        var text = first == last
+            ? first.ToString(format, CultureInfo.InvariantCulture)
+            : first.ToString(format, CultureInfo.InvariantCulture) + " - " + last.ToString(format, CultureInfo.InvariantCulture);
+        InputBox.Text = text;
+        InputBox.CaretIndex = text.Length;
+    }
+
+    // ---- calendar theming (replaces the per-app copies of ApplyThemeToCalendar) ----
+
+    private Brush Res(string key, Brush fallback)
+        => TryFindResource(key) as Brush ?? fallback;
+
+    private static bool IsDark(Brush background)
+        => background is SolidColorBrush solid
+           && (0.299 * solid.Color.R + 0.587 * solid.Color.G + 0.114 * solid.Color.B) < 128;
+
+    /// <summary>Paints the calendar from the theme's brushes: the stock Calendar template is light, so a dark theme needs its chrome recoloured.</summary>
+    private void ApplyCalendarTheme()
+    {
+        var background = Res("BackgroundBrush", Brushes.White);
+        var foreground = Res("ForegroundBrush", Brushes.Black);
+        var border = Res("BorderBrush", Brushes.Gray);
+        PickCalendar.Background = background;
+        PickCalendar.Foreground = foreground;
+        PickCalendar.BorderBrush = border;
+        PaintCalendarTree(PickCalendar, background, foreground, IsDark(background));
+    }
+
+    private static void PaintCalendarTree(DependencyObject parent, Brush background, Brush foreground, bool dark)
+    {
+        for (var i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
+        {
+            var child = VisualTreeHelper.GetChild(parent, i);
+            switch (child)
+            {
+                case CalendarItem item:
+                    item.Background = background;
+                    item.Foreground = foreground;
+                    break;
+                case CalendarDayButton day:
+                    if (!day.IsSelected)
+                    {
+                        day.Background = Brushes.Transparent;
+                    }
+
+                    day.Foreground = foreground;
+                    break;
+                case CalendarButton month:
+                    month.Background = Brushes.Transparent;
+                    month.Foreground = foreground;
+                    break;
+                case Button button:
+                    button.Background = Brushes.Transparent;
+                    button.Foreground = foreground;
+                    break;
+                case TextBlock text:
+                    text.Foreground = foreground;
+                    break;
+                case Border border when dark && border.Background is SolidColorBrush bg && bg.Color.R > 200 && bg.Color.G > 200 && bg.Color.B > 200:
+                    border.Background = background;
+                    break;
+                case Grid grid when dark && grid.Background is SolidColorBrush gridBg && gridBg.Color.R > 200 && gridBg.Color.G > 200 && gridBg.Color.B > 200:
+                    grid.Background = background;
+                    break;
+            }
+
+            PaintCalendarTree(child, background, foreground, dark);
+        }
+    }
+}

From 6ca61ec9b67c8cc38208d5b682b226948d2c4cde Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 09:53:59 -0400
Subject: [PATCH 03/33] Web and MCP: a per-read window ceiling, and the reach
 table the web picker reads (#5562)

ValidateWindow gets an overload that takes the read's own ceiling and refuses beyond it. The query, procedure and Query Store duration trends opt in at 90 days; every other read stays at 168 hours. WebReadReach is the one table of reach and main collector per windowed read, served on the catalog's hours param as max_hours, shape and the collector's interval.
---
 Darling/Darling.Tests/WebReadReachTests.cs    | 279 ++++++++++++++++++
 .../DarlingWebEndpoints.cs                    |  66 ++++-
 .../Mcp/DarlingMcpTrendTools.cs               |  15 +-
 .../WebReadReach.cs                           | 211 +++++++++++++
 PerformanceMonitor.Common/Mcp/McpHelpers.cs   |  37 ++-
 5 files changed, 592 insertions(+), 16 deletions(-)
 create mode 100644 Darling/Darling.Tests/WebReadReachTests.cs
 create mode 100644 Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs

diff --git a/Darling/Darling.Tests/WebReadReachTests.cs b/Darling/Darling.Tests/WebReadReachTests.cs
new file mode 100644
index 0000000000..d086a8f0c7
--- /dev/null
+++ b/Darling/Darling.Tests/WebReadReachTests.cs
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * 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.Text.Json.Nodes;
+using System.Text.RegularExpressions;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Service;
+using Xunit;
+using static Darling.Tests.RepoFile;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// #5562 (lane L4): the per-read reach the web picker reads. <see cref="WebReadReach"/> is the one table; these tests
+/// pin that it covers every windowed web read (a census that fails when a read is added without a row), that the
+/// catalog serves it as <c>max_hours</c> on the read's <c>hours</c> param, that only bucketed trends reach past
+/// <see cref="McpHelpers.MaxHoursBack"/>, that the validator of each such read takes its ceiling from the table, and
+/// that the <c>ValidateWindow</c> overload refuses (never clamps) beyond the ceiling it is handed.
+/// </summary>
+public sealed class WebReadReachTests
+{
+    private static string[] WindowedReads() =>
+        DarlingWebEndpoints.CatalogDescriptors
+            .Where(kv => kv.Value.Params.Any(p => p.Name == "hours"))
+            .Select(kv => kv.Key)
+            .OrderBy(n => n, StringComparer.Ordinal)
+            .ToArray();
+
+    private static JsonObject HoursParam(JsonObject catalog, string read) =>
+        catalog["reads"]!.AsArray()
+            .Single(r => r!["name"]!.GetValue<string>() == read)!["params"]!.AsArray()
+            .Single(p => p!["name"]!.GetValue<string>() == "hours")!.AsObject();
+
+    /* ───────────── the census ───────────── */
+
+    [Fact]
+    public void EveryWindowedWebRead_HasARowInTheReachTable()
+    {
+        var missing = WindowedReads().Where(n => !WebReadReach.All.ContainsKey(n)).ToArray();
+        Assert.True(
+            missing.Length == 0,
+            "These web reads take an hours param but have no row in WebReadReach.All (#5562: add the read's reach and main collector): "
+            + string.Join(", ", missing));
+    }
+
+    [Fact]
+    public void EveryRowInTheReachTable_NamesAWindowedWebRead()
+    {
+        var windowed = WindowedReads().ToHashSet(StringComparer.Ordinal);
+        var orphans = WebReadReach.All.Keys.Where(n => !windowed.Contains(n)).OrderBy(n => n, StringComparer.Ordinal).ToArray();
+        Assert.True(
+            orphans.Length == 0,
+            "These WebReadReach rows name no windowed web read (renamed or removed read, or a read with no hours param): "
+            + string.Join(", ", orphans));
+    }
+
+    [Fact]
+    public void EveryRow_NamesACollectorTheDefaultsKnow_OrNone()
+    {
+        foreach (var (read, reach) in WebReadReach.All)
+        {
+            if (reach.Collector is not null)
+            {
+                Assert.True(
+                    CollectorScheduleDefaults.All.ContainsKey(reach.Collector),
+                    $"{read} names collector '{reach.Collector}', which CollectorScheduleDefaults does not know.");
+            }
+        }
+    }
+
+    /* ───────────── what reaches past 168 hours ───────────── */
+
+    [Fact]
+    public void OnlyBucketedTrends_ReachPastTheDefault_AndNoneReachesPastTheirRollup()
+    {
+        foreach (var (read, reach) in WebReadReach.All)
+        {
+            if (reach.MaxHours > McpHelpers.MaxHoursBack)
+            {
+                Assert.True(reach.Shape == ReadShape.BucketedTrend, $"{read} reaches {reach.MaxHours} h but is a {reach.Shape}; lists and rankings stay at {McpHelpers.MaxHoursBack}.");
+                Assert.True(reach.MaxHours <= WebReadReach.RollupTrendHours, $"{read} reaches past the hourly rollup's 90 days.");
+            }
+            else
+            {
+                Assert.Equal(McpHelpers.MaxHoursBack, reach.MaxHours);
+            }
+        }
+
+        Assert.Equal(
+            new[] { "get_procedure_duration_trend", "get_query_duration_trend", "get_query_store_duration_trend" },
+            WebReadReach.All.Where(kv => kv.Value.MaxHours > McpHelpers.MaxHoursBack).Select(kv => kv.Key).OrderBy(n => n, StringComparer.Ordinal).ToArray());
+        Assert.Equal(2160, WebReadReach.RollupTrendHours);
+    }
+
+    /// <summary>
+    /// The validator of each opted-in read takes its ceiling from the table, and no other tool does: a row that says
+    /// 2,160 with a validator still on the 168-hour overload would advertise a window the read then refuses, and a
+    /// validator that opts in with no row would reach further than the picker was told.
+    /// </summary>
+    [Fact]
+    public void EveryOptedInValidator_NamesAReadWhoseRowReachesPast168_AndEveryRowThatDoesIsOptedIn()
+    {
+        var serviceDir = PathTo("Darling", "PerformanceMonitor.Darling.Service");
+        var optedIn = new Dictionary<string, int>(StringComparer.Ordinal);
+        foreach (var file in System.IO.Directory.EnumerateFiles(serviceDir, "*.cs", System.IO.SearchOption.AllDirectories))
+        {
+            if (file.EndsWith("WebReadReach.cs", StringComparison.Ordinal)
+                || file.Contains($"{System.IO.Path.DirectorySeparatorChar}obj{System.IO.Path.DirectorySeparatorChar}", StringComparison.Ordinal)
+                || file.Contains($"{System.IO.Path.DirectorySeparatorChar}bin{System.IO.Path.DirectorySeparatorChar}", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            foreach (Match m in Regex.Matches(System.IO.File.ReadAllText(file), @"WebReadReach\.MaxHoursFor\(""(?<read>[a-z_0-9]+)""\)"))
+            {
+                var read = m.Groups["read"].Value;
+                optedIn[read] = optedIn.GetValueOrDefault(read) + 1;
+            }
+        }
+
+        foreach (var read in optedIn.Keys)
+        {
+            Assert.True(
+                WebReadReach.All.TryGetValue(read, out var reach) && reach.MaxHours > McpHelpers.MaxHoursBack,
+                $"{read}'s validator takes its ceiling from the table, but its row does not reach past {McpHelpers.MaxHoursBack}.");
+        }
+
+        foreach (var (read, reach) in WebReadReach.All.Where(kv => kv.Value.MaxHours > McpHelpers.MaxHoursBack))
+        {
+            Assert.True(optedIn.GetValueOrDefault(read) == 1, $"{read} reaches {reach.MaxHours} h in the table but {optedIn.GetValueOrDefault(read)} validator(s) read that ceiling (want exactly one).");
+        }
+    }
+
+    [Fact]
+    public void MaxHoursFor_ThrowsForAReadWithNoRow_AndAnswersTheTableForOne()
+    {
+        Assert.Equal(2160, WebReadReach.MaxHoursFor("get_query_duration_trend"));
+        Assert.Equal(168, WebReadReach.MaxHoursFor("get_top_queries_by_cpu"));
+        Assert.Throws<InvalidOperationException>(() => WebReadReach.MaxHoursFor("get_no_such_read"));
+    }
+
+    /* ───────────── the catalog ───────────── */
+
+    [Fact]
+    public void Catalog_EveryHoursParam_CarriesMaxHoursFromTheTable()
+    {
+        var catalog = DarlingWebEndpoints.BuildCatalogNode();
+        foreach (var read in WindowedReads())
+        {
+            var hours = HoursParam(catalog, read);
+            var reach = WebReadReach.All[read];
+            Assert.Equal(reach.MaxHours, hours["max_hours"]!.GetValue<int>());
+            Assert.Equal(reach.Collector, hours["collector"]?.GetValue<string>());
+            Assert.NotNull(hours["shape"]);
+        }
+
+        Assert.Equal(2160, HoursParam(catalog, "get_query_store_duration_trend")["max_hours"]!.GetValue<int>());
+        Assert.Equal(168, HoursParam(catalog, "get_wait_trend")["max_hours"]!.GetValue<int>());
+        Assert.Equal("bucketed_trend", HoursParam(catalog, "get_wait_trend")["shape"]!.GetValue<string>());
+        Assert.Equal("latest_snapshot", HoursParam(catalog, "get_active_queries")["shape"]!.GetValue<string>());
+    }
+
+    [Fact]
+    public void Catalog_OnlyTheHoursParamCarriesReach()
+    {
+        var catalog = DarlingWebEndpoints.BuildCatalogNode();
+        foreach (var read in catalog["reads"]!.AsArray())
+        {
+            foreach (var p in read!["params"]!.AsArray())
+            {
+                var isHours = p!["name"]!.GetValue<string>() == "hours";
+                Assert.Equal(isHours, p.AsObject().ContainsKey("max_hours"));
+            }
+        }
+    }
+
+    [Fact]
+    public void Catalog_CollectorInterval_IsTheShippedDefaultUntilTheStoreHoldsASchedule()
+    {
+        var plain = HoursParam(DarlingWebEndpoints.BuildCatalogNode(), "get_query_store_duration_trend");
+        Assert.Equal("query_store", plain["collector"]!.GetValue<string>());
+        Assert.Equal(5, plain["collector_interval_minutes"]!.GetValue<int>());
+        Assert.Equal(5, plain["collector_default_interval_minutes"]!.GetValue<int>());
+
+        var oneMinute = HoursParam(DarlingWebEndpoints.BuildCatalogNode(), "get_wait_trend");
+        Assert.Equal(1, oneMinute["collector_interval_minutes"]!.GetValue<int>());
+
+        var noCollector = HoursParam(DarlingWebEndpoints.BuildCatalogNode(), "get_analysis_findings");
+        Assert.Null(noCollector["collector"]);
+        Assert.Null(noCollector["collector_interval_minutes"]);
+        Assert.Null(noCollector["collector_default_interval_minutes"]);
+    }
+
+    [Fact]
+    public void Catalog_CollectorInterval_FollowsTheScheduleInForce_PerServerOverFleetOverDefault()
+    {
+        var schedules = new[]
+        {
+            new ScheduleOverride(null, "query_store", 15, null, null),
+            new ScheduleOverride(7, "query_store", 30, null, null),
+            new ScheduleOverride(7, "wait_stats", 2, null, null),
+        };
+
+        /* No server: the fleet-wide row, and only it. */
+        var fleet = DarlingWebEndpoints.BuildCatalogNode(null, schedules);
+        Assert.Equal(15, HoursParam(fleet, "get_query_store_duration_trend")["collector_interval_minutes"]!.GetValue<int>());
+        Assert.Equal(1, HoursParam(fleet, "get_wait_trend")["collector_interval_minutes"]!.GetValue<int>());
+
+        /* Server 7: its own row wins over the fleet's, a column it does not set falls through, the default stays visible. */
+        var server = DarlingWebEndpoints.BuildCatalogNode(7, schedules);
+        var qs = HoursParam(server, "get_query_store_duration_trend");
+        Assert.Equal(30, qs["collector_interval_minutes"]!.GetValue<int>());
+        Assert.Equal(5, qs["collector_default_interval_minutes"]!.GetValue<int>());
+        Assert.Equal(2, HoursParam(server, "get_wait_trend")["collector_interval_minutes"]!.GetValue<int>());
+
+        /* Another server sees the fleet's row, not server 7's. */
+        Assert.Equal(15, HoursParam(DarlingWebEndpoints.BuildCatalogNode(8, schedules), "get_query_store_duration_trend")["collector_interval_minutes"]!.GetValue<int>());
+    }
+
+    /* ───────────── the McpHelpers overload ───────────── */
+
+    [Fact]
+    public void ValidateWindow_WithACeiling_AcceptsUpToItAndRefusesBeyondWithoutClamping()
+    {
+        Assert.Null(McpHelpers.ValidateWindow(2160, null, 2160, out _));
+        Assert.Null(McpHelpers.ValidateWindow(1, null, 2160, out _));
+
+        var over = McpHelpers.ValidateWindow(2161, null, 2160, out _);
+        Assert.NotNull(over);
+        var message = McpHelpers.ErrorMessageOf(over!);
+        Assert.Contains("2161", message);
+        Assert.Contains("maximum of 2160 hours (90 days)", message);
+
+        var zero = McpHelpers.ErrorMessageOf(McpHelpers.ValidateWindow(0, null, 2160, out _)!);
+        Assert.Contains("(1-2160)", zero);
+    }
+
+    [Fact]
+    public void ValidateWindow_WithACeiling_ChecksTheSpanBeforeTheAnchor_AndStillResolvesAsOf()
+    {
+        var spanFirst = McpHelpers.ValidateWindow(3000, "not a date", 2160, out _);
+        Assert.Contains("hours_back", spanFirst!);
+
+        var anchorBad = McpHelpers.ValidateWindow(2000, "not a date", 2160, out _);
+        Assert.NotNull(anchorBad);
+        Assert.Contains("as_of", anchorBad!);
+
+        var asOf = new DateTime(2026, 9, 1, 12, 0, 0, DateTimeKind.Utc);
+        Assert.Null(McpHelpers.ValidateWindow(2000, asOf.ToString("o"), 2160, out var end));
+        Assert.Equal(asOf, end);
+    }
+
+    [Fact]
+    public void ValidateWindow_WithoutACeiling_StaysAt168_AndSaysTheSameWords()
+    {
+        Assert.Equal(168, McpHelpers.MaxHoursBack);
+        Assert.Null(McpHelpers.ValidateWindow(168, null, out _));
+        Assert.NotNull(McpHelpers.ValidateWindow(169, null, out _));
+        Assert.Equal(McpHelpers.ValidateHoursBack(169), McpHelpers.ValidateHoursBack(169, 168));
+        Assert.Equal(McpHelpers.ValidateWindow(169, null, out _), McpHelpers.ValidateWindow(169, null, 168, out _));
+        Assert.Contains("exceeds maximum of 168 hours (7 days)", McpHelpers.ErrorMessageOf(McpHelpers.ValidateHoursBack(169)!));
+        Assert.Contains("(1-168)", McpHelpers.ErrorMessageOf(McpHelpers.ValidateHoursBack(0)!));
+    }
+
+    [Fact]
+    public void ACeilingThatIsNotWholeDays_IsSpelledInHours()
+    {
+        Assert.Contains("maximum of 100 hours. Use", McpHelpers.ErrorMessageOf(McpHelpers.ValidateHoursBack(101, 100)!));
+    }
+}
diff --git a/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs b/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
index 439c265fdb..3ae8dae16c 100644
--- a/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
@@ -503,7 +503,28 @@ constant is what makes the SPA's read-only rendering reachable — it hides ever
             JsonNodeResult(new JsonObject { ["can_edit"] = DarlingWebSeat.FromContext(context).CanEdit }));
 
         /* The read catalog: input truth (read names + their WIRE query keys) the composer binds params from. */
-        app.MapGet("/api/catalog", () => JsonNodeResult(BuildCatalogNode()));
+        /* #5562: ?server= makes the collector intervals the SERVER's own (a per-server schedule row wins over the
+           fleet-wide one); without it they are the fleet-wide effective interval. Either way the read's reach
+           (max_hours) is the same: it belongs to the read, not the server. An unknown server is answered with the
+           resolver's refusal, not a silent fall back to the fleet's numbers. */
+        app.MapGet("/api/catalog", async (HttpContext context) =>
+        {
+            var serverName = context.Request.Query["server"].ToString();
+            if (string.IsNullOrWhiteSpace(serverName))
+            {
+                var fleetSchedules = await DarlingDataReader.ReadScheduleOverridesAsync(postgres, null, context.RequestAborted);
+                return JsonNodeResult(BuildCatalogNode(null, fleetSchedules));
+            }
+
+            var (resolved, resolveError) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, serverName, context.RequestAborted);
+            if (resolveError != null)
+            {
+                return JsonNodeResult(JsonNode.Parse(resolveError)!.AsObject());
+            }
+
+            var schedules = await DarlingDataReader.ReadScheduleOverridesAsync(postgres, resolved.ServerId, context.RequestAborted);
+            return JsonNodeResult(BuildCatalogNode(resolved.ServerId, schedules));
+        });
 
         /* List — a bare array of summaries (no definition); [] when none. */
         app.MapGet("/api/views", async (HttpContext context) =>
@@ -4649,7 +4670,16 @@ fetched when its Analysis row is first expanded. The key is the page's own row i
     /// <summary>Builds the <c>/api/catalog</c> body: the reads (names taken from <see cref="BuildReadDispatch"/>,
     /// each enriched with its <see cref="CatalogDescriptors"/> metadata) and the viz vocabulary. Iterating the
     /// dispatch keys guarantees the catalog only advertises actually-dispatchable reads.</summary>
-    internal static JsonObject BuildCatalogNode()
+    internal static JsonObject BuildCatalogNode() => BuildCatalogNode(null, Array.Empty<ScheduleOverride>());
+
+    /// <summary>
+    /// The catalog with each windowed read's reach (#5562): its <c>hours</c> param carries <c>max_hours</c> (the longest
+    /// window the read's validator accepts, from <see cref="WebReadReach"/>), <c>shape</c>, and the main collector's
+    /// <c>collector</c> id, <c>collector_interval_minutes</c> (the schedule in force: <paramref name="schedules"/> over
+    /// the shipped default) and <c>collector_default_interval_minutes</c>, so the picker can grey out a longer period
+    /// with its reason and say "collected every N minutes" under a range too short to hold three samples.
+    /// </summary>
+    internal static JsonObject BuildCatalogNode(int? serverId, IReadOnlyList<ScheduleOverride> schedules)
     {
         var reads = new JsonArray();
         foreach (var name in BuildReadDispatch().Keys)
@@ -4658,13 +4688,19 @@ internal static JsonObject BuildCatalogNode()
             var parameters = new JsonArray();
             foreach (var p in descriptor.Params)
             {
-                parameters.Add(new JsonObject
+                var param = new JsonObject
                 {
                     ["name"] = p.Name,
                     ["type"] = p.Type,
                     ["required"] = p.Required,
                     ["default"] = ToJsonValue(p.Default),
-                });
+                };
+                if (p.Name == "hours")
+                {
+                    AddReach(param, name, serverId, schedules);
+                }
+
+                parameters.Add(param);
             }
 
             reads.Add(new JsonObject
@@ -4686,6 +4722,28 @@ internal static JsonObject BuildCatalogNode()
         return new JsonObject { ["reads"] = reads, ["viz"] = viz, ["compose"] = BuildComposeCatalogNode() };
     }
 
+    /// <summary>Adds a windowed read's reach to its <c>hours</c> catalog param (#5562). A read with no row in
+    /// <see cref="WebReadReach.All"/> is advertised at the default reach with no collector; a census keeps that case
+    /// from shipping.</summary>
+    private static void AddReach(JsonObject param, string read, int? serverId, IReadOnlyList<ScheduleOverride> schedules)
+    {
+        WebReadReach.All.TryGetValue(read, out var reach);
+        var shape = reach?.Shape switch
+        {
+            ReadShape.BucketedTrend => "bucketed_trend",
+            ReadShape.LatestSnapshot => "latest_snapshot",
+            _ => "list",
+        };
+        var collector = reach?.Collector;
+        param["max_hours"] = reach?.MaxHours ?? WebReadReach.DefaultHours;
+        param["shape"] = shape;
+        param["collector"] = collector;
+        param["collector_interval_minutes"] = WebReadReach.CollectorIntervalMinutes(collector, serverId, schedules);
+        param["collector_default_interval_minutes"] = collector is not null && CollectorScheduleDefaults.All.TryGetValue(collector, out var def)
+            ? CollectorScheduleDefaults.EffectiveRecurringIntervalMinutes(def.FrequencyMinutes)
+            : null;
+    }
+
     /// <summary>
     /// The v2 (Custom Views composer) catalog: the measure/dimension/unit-family/aggregate/time-bucket/filter-op
     /// vocabularies the composer picks from, straight off <see cref="MeasureCatalog"/> (the SOLE identifier
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
index f09012c503..47534df942 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
@@ -497,7 +497,7 @@ want opposite remedies — see the class remarks and McpHelpers.WindowTruncatedD
     public static Task<string> GetQueryDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 2160 (90 days), served from the hourly rollup past the raw tier's four days.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
@@ -524,7 +524,8 @@ internal static async Task<string> GetQueryDurationTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: a bucketed trend that routes through the hourly rollup opts in to the 90-day reach WebReadReach declares; every other read keeps 168. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_query_duration_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
@@ -596,7 +597,7 @@ is not a server nothing was ever stored for. */
     public static Task<string> GetProcedureDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 2160 (90 days), served from the hourly rollup past the raw tier's four days.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
@@ -618,7 +619,8 @@ internal static async Task<string> GetProcedureDurationTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: a bucketed trend that routes through the hourly rollup opts in to the 90-day reach WebReadReach declares; every other read keeps 168. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_procedure_duration_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
@@ -672,7 +674,7 @@ width rule on the hourly tier. */
     public static Task<string> GetQueryStoreDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 2160 (90 days), served from the hourly rollup past the raw tier's four days.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
         CancellationToken cancellationToken = default) =>
@@ -690,7 +692,8 @@ internal static async Task<string> GetQueryStoreDurationTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: a bucketed trend that routes through the hourly rollup opts in to the 90-day reach WebReadReach declares; every other read keeps 168. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_query_store_duration_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         try
diff --git a/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
new file mode 100644
index 0000000000..df1914735f
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Common;
+
+namespace PerformanceMonitor.Darling.Service;
+
+/// <summary>What a windowed web / MCP read returns, which decides how far back it may ever be asked to reach (#5562).</summary>
+internal enum ReadShape
+{
+    /// <summary>Points grouped into time buckets (<c>bucket_minutes</c>): the payload is bounded by the bucket budget,
+    /// not by the window, so it is the only shape allowed past <see cref="McpHelpers.MaxHoursBack"/>.</summary>
+    BucketedTrend,
+
+    /// <summary>A list or a ranking (top-N, newest-first rows, an unbucketed series): its payload grows with the window,
+    /// so it stays at <see cref="McpHelpers.MaxHoursBack"/>.</summary>
+    List,
+
+    /// <summary>The latest snapshot: the window is only a freshness bound, so a longer range means nothing here.</summary>
+    LatestSnapshot,
+}
+
+/// <summary>
+/// One windowed read's reach: its <see cref="Shape"/>, the longest window it accepts (<see cref="MaxHours"/>, the number
+/// the read's own validator enforces) and the collector whose cadence decides how many samples a short window holds.
+/// </summary>
+/// <param name="Shape">What the read returns.</param>
+/// <param name="MaxHours">The longest <c>hours</c> the read accepts; the web picker greys out anything longer.</param>
+/// <param name="Collector">The main collector id (a <see cref="CollectorScheduleDefaults"/> key), or null for a read
+/// that no collector feeds (analysis, alert history, the store's own self-monitoring).</param>
+internal sealed record ReadReach(ReadShape Shape, int MaxHours, string? Collector);
+
+/// <summary>
+/// The ONE table of how far back each windowed web read reaches and which collector feeds it (#5562, rulings R2 and R3).
+///
+/// <para><b>Why a table.</b> The picker on the server page offers presets from five minutes to a quarter, and it must
+/// grey out a period a tab cannot read, with the reason. The answer cannot live in the page: the read's validator is the
+/// authority, and a page that guessed would offer a window the read then refuses. So the validator of every read that
+/// reaches past a week takes its ceiling from here (<see cref="MaxHoursFor"/>), the catalog serves the same number as
+/// <c>max_hours</c> on the read's <c>hours</c> parameter, and a census (<c>WebReadReachTests</c>) fails when a windowed
+/// read is added without a row, so a new read cannot ship with no declared reach.</para>
+///
+/// <para><b>What reaches past seven days.</b> Only a BUCKETED trend read that routes through the hourly rollup the
+/// Custom Views way (<c>RetentionTierRouter</c>, <c>DurationTrendRouting</c>, <c>QueryStoreTrendRouting</c>): the
+/// query, procedure and Query Store duration trends, at <see cref="RollupTrendHours"/> (90 days, what the rollups
+/// keep). Their payload is whole-hour points, so 90 days is at most 2,160 of them. Lists and rankings stay at
+/// <see cref="McpHelpers.MaxHoursBack"/> even where they route through a rollup (a top-N over 90 days is a different
+/// payload, and the MCP ceiling rises for bucketed trends only); query text and plans are kept for a few days only
+/// (<c>RetentionTierRouter.ClampToTextHorizon</c>), and none of the three opted-in reads carries either.
+/// The raw-table bucketed trends (waits, CPU, memory, file I/O, tempdb, perfmon, blocking) stay at 168 hours in code
+/// until a timing run on a large store says a month is affordable; raising one is a one-line change to its row here,
+/// plus its validator call, and nothing else.</para>
+/// </summary>
+internal static class WebReadReach
+{
+    /// <summary>The reach of every read that has not opted in: <see cref="McpHelpers.MaxHoursBack"/>.</summary>
+    public const int DefaultHours = McpHelpers.MaxHoursBack;
+
+    /// <summary>The rollup-routed trends' reach: 90 days, the hourly rollup's retention (and Custom Views'
+    /// <c>ComposeLimits.MaxWindowHours</c>).</summary>
+    public const int RollupTrendHours = 24 * 90;
+
+    private static ReadReach Trend(string? collector, int maxHours = DefaultHours) => new(ReadShape.BucketedTrend, maxHours, collector);
+    private static ReadReach List(string? collector) => new(ReadShape.List, DefaultHours, collector);
+    private static ReadReach Snapshot(string? collector) => new(ReadShape.LatestSnapshot, DefaultHours, collector);
+
+    /// <summary>Every windowed read (one with an <c>hours</c> parameter in the web catalog), by read name.</summary>
+    public static readonly IReadOnlyDictionary<string, ReadReach> All = new Dictionary<string, ReadReach>(StringComparer.Ordinal)
+    {
+        /* Rollup-routed bucketed trends: the only reads past 168 hours. */
+        ["get_query_duration_trend"] = Trend("query_stats", RollupTrendHours),
+        ["get_procedure_duration_trend"] = Trend("procedure_stats", RollupTrendHours),
+        ["get_query_store_duration_trend"] = Trend("query_store", RollupTrendHours),
+
+        /* Raw-table bucketed trends: 168 hours until the large-store timing run (item 4 of #5562's L4 lane). */
+        ["get_blocking_trend"] = Trend("blocked_process_report"),
+        ["get_deadlock_trend"] = Trend("deadlocks"),
+        ["get_lock_wait_trend"] = Trend("wait_stats"),
+        ["get_current_waits_trend"] = Trend("waiting_tasks"),
+        ["get_blocking_stats"] = Trend("dmv_blocking_snapshot"),
+        ["get_cpu_utilization"] = Trend("cpu_utilization"),
+        ["get_query_heatmap"] = Trend("query_stats"),
+        ["get_tempdb_trend"] = Trend("tempdb_stats"),
+        ["get_wait_trend"] = Trend("wait_stats"),
+        ["get_file_io_trend"] = Trend("file_io_stats"),
+        ["get_memory_trend"] = Trend("memory_stats"),
+        ["get_server_trend"] = Trend(null),
+        ["get_perfmon_trend"] = Trend("perfmon_stats"),
+        ["get_pg_cpu_utilization"] = Trend("pg_cpu_utilization"),
+        ["get_pg_wait_trend"] = Trend("pg_wait_sampling"),
+        ["get_pg_query_duration_trend"] = Trend("pg_statement_stats"),
+        ["get_pg_io_trend"] = Trend("pg_io_stats"),
+        ["get_pg_database_trend"] = Trend("pg_database_stats"),
+
+        /* Lists, rankings and unbucketed series. */
+        ["get_top_queries_by_cpu"] = List("query_stats"),
+        ["get_top_procedures_by_cpu"] = List("procedure_stats"),
+        ["get_query_trend"] = List("query_stats"),
+        ["get_query_store_top"] = List("query_store"),
+        ["get_query_store_regressions"] = List("query_store"),
+        ["get_query_store_clutter"] = List("query_store"),
+        ["get_query_store_query_history"] = List("query_store"),
+        ["get_long_query_completions"] = List("long_query_completions"),
+        ["get_plan_corrections"] = List("plan_correction"),
+        ["get_blocked_process_xml"] = List("blocked_process_report"),
+        ["get_blocking"] = List("blocked_process_report"),
+        ["get_deadlocks"] = List("deadlocks"),
+        ["get_deadlock_detail"] = List("deadlocks"),
+        ["get_database_config_changes"] = List("database_config"),
+        ["get_server_config_changes"] = List("server_config"),
+        ["get_trace_flag_changes"] = List("trace_flags"),
+        ["get_collection_log"] = List(null),
+        ["get_wait_stats"] = List("wait_stats"),
+        ["get_wait_types"] = List("wait_stats"),
+        ["get_latch_stats"] = List("latch_stats"),
+        ["get_spinlock_stats"] = List("spinlock_stats"),
+        ["get_memory_pressure_events"] = List("memory_pressure_events"),
+        ["get_resource_semaphore"] = List("memory_grant_stats"),
+        ["get_plan_cache_bloat"] = List("plan_cache_stats"),
+        ["get_job_history"] = List("job_history"),
+        ["get_default_trace_events"] = List("default_trace_events"),
+        ["get_health_parser_cpu_tasks"] = List("system_health_events"),
+        ["get_health_parser_io_issues"] = List("system_health_events"),
+        ["get_health_parser_memory_broker"] = List("system_health_events"),
+        ["get_health_parser_memory_conditions"] = List("system_health_events"),
+        ["get_health_parser_memory_node_oom"] = List("system_health_events"),
+        ["get_health_parser_scheduler_issues"] = List("system_health_events"),
+        ["get_health_parser_severe_errors"] = List("system_health_events"),
+        ["get_health_parser_significant_waits"] = List("system_health_events"),
+        ["get_health_parser_system_health"] = List("system_health_events"),
+        ["get_pg_top_queries"] = List("pg_statement_stats"),
+        ["get_pg_plans"] = List("pg_plan_capture"),
+        ["get_pg_io_stats"] = List("pg_io_stats"),
+        ["get_pg_wait_stats"] = List("pg_wait_stats"),
+        ["get_pg_wait_sampling"] = List("pg_wait_sampling"),
+        ["get_pg_kernel_stats"] = List("pg_kernel_stats"),
+        ["get_pg_predicate_stats"] = List("pg_predicate_stats"),
+        ["get_pg_lock_stats"] = List("pg_lock_stats"),
+        ["get_pg_write_stats"] = List("pg_write_stats"),
+        ["get_pg_server_config_changes"] = List("pg_server_config"),
+        ["get_pg_deadlocks"] = List("pg_deadlocks"),
+        ["get_pg_log_events"] = List("pg_log_events"),
+        ["get_pg_blocking"] = List("pg_blocking"),
+        ["get_pg_database_stats"] = List("pg_database_stats"),
+        ["get_pg_session_states"] = List("pg_session_states"),
+
+        /* Latest snapshots: the window is a freshness bound. */
+        ["get_active_queries"] = Snapshot("query_snapshots"),
+        ["get_waiting_tasks"] = Snapshot("waiting_tasks"),
+        ["get_memory_grants"] = Snapshot("memory_grant_stats"),
+        ["get_cpu_scheduler_pressure"] = Snapshot("cpu_scheduler_stats"),
+        ["get_pg_plan_capture_readiness"] = Snapshot("pg_plan_capture_readiness"),
+        ["get_pg_wraparound_risk"] = Snapshot("pg_wraparound_stats"),
+        ["get_pg_xmin_horizon"] = Snapshot("pg_xmin_horizon"),
+        ["get_pg_replication_slots"] = Snapshot("pg_replication_slots"),
+        ["get_pg_replication_stats"] = Snapshot("pg_replication_stats"),
+        ["get_pg_autovacuum_health"] = Snapshot("pg_autovacuum_stats"),
+        ["get_pg_index_bloat"] = Snapshot("pg_index_bloat"),
+        ["get_pg_column_stats"] = Snapshot("pg_column_stats"),
+        ["get_pg_buffer_usage"] = Snapshot("pg_buffer_usage"),
+        ["get_pg_extensions"] = Snapshot("pg_extension_availability"),
+        ["get_pg_index_usage"] = Snapshot("pg_index_usage_stats"),
+        ["get_pg_table_bloat"] = Snapshot("pg_table_bloat_stats"),
+
+        /* No collector feeds these: analysis, alerts, fleet, and the monitoring tool's own self-monitoring. */
+        ["compare_analysis"] = List(null),
+        ["get_analysis_facts"] = List(null),
+        ["get_analysis_findings"] = List(null),
+        ["get_alert_history"] = List(null),
+        ["get_fleet_overview"] = List(null),
+        ["get_sweep_reports"] = List(null),
+        ["get_store_log"] = List(null),
+        ["get_store_query_history"] = List(null),
+        ["get_slow_reads"] = List(null),
+        ["get_read_latency"] = List(null),
+        ["get_finops"] = List(null),
+    };
+
+    /// <summary>
+    /// The ceiling a read's validator passes to <see cref="McpHelpers.ValidateWindow(int, string?, int, out DateTime)"/>.
+    /// Throws for a read with no row: a validator that names a read the table does not know has drifted from the table,
+    /// and failing loudly beats quietly accepting 168 for a read the picker was told reaches further.
+    /// </summary>
+    public static int MaxHoursFor(string read) =>
+        All.TryGetValue(read, out var reach)
+            ? reach.MaxHours
+            : throw new InvalidOperationException($"#5562: '{read}' has no row in WebReadReach.All.");
+
+    /// <summary>
+    /// The collector's interval in minutes: <paramref name="overrides"/> (the schedule rows the store holds, per server
+    /// when <paramref name="serverId"/> is given, else only the fleet-wide row) over the shipped default. Null for a read
+    /// no collector feeds or a collector name the defaults do not know.
+    /// </summary>
+    public static int? CollectorIntervalMinutes(string? collector, int? serverId, IReadOnlyList<ScheduleOverride> overrides)
+    {
+        if (collector is null || !CollectorScheduleDefaults.All.ContainsKey(collector))
+        {
+            return null;
+        }
+
+        return CollectorScheduleDefaults.ResolveEffectiveIntervalMinutes(collector, serverId ?? -1, overrides);
+    }
+}
diff --git a/PerformanceMonitor.Common/Mcp/McpHelpers.cs b/PerformanceMonitor.Common/Mcp/McpHelpers.cs
index 26cb6b0345..d0eb3d29b5 100644
--- a/PerformanceMonitor.Common/Mcp/McpHelpers.cs
+++ b/PerformanceMonitor.Common/Mcp/McpHelpers.cs
@@ -175,15 +175,32 @@ private static bool IsAsciiBoundary(ReadOnlySpan<char> text, int index) =>
     /// text) reads them back through <see cref="ErrorMessageOf"/>; nothing concatenates a validator's return
     /// any more, because it is no longer text.</para>
     /// </summary>
-    public static string? ValidateHoursBack(int hoursBack)
+    public static string? ValidateHoursBack(int hoursBack) => ValidateHoursBack(hoursBack, MaxHoursBack);
+
+    /// <summary>
+    /// <see cref="ValidateHoursBack(int)"/> against a ceiling the READ declares (#5562): the per-read opt-in by which
+    /// a bucketed trend read accepts a window longer than <see cref="MaxHoursBack"/>. Same two refusals, same envelope,
+    /// same sentences with the ceiling swapped in, so a caller who has seen the 168-hour refusal recognises this one.
+    /// Refuses, never clamps: a window past <paramref name="maxHours"/> is an error, not a quietly shorter question.
+    ///
+    /// <para><see cref="MaxHoursBack"/> itself never moves. A read opts in by passing its own ceiling here (one line
+    /// per read, from the web read-reach table), and every read that does not keeps the 168-hour rule.</para>
+    /// </summary>
+    public static string? ValidateHoursBack(int hoursBack, int maxHours)
     {
         if (hoursBack <= 0)
-            return Refusal("hours_back", $"Invalid hours_back value '{hoursBack}'. Must be a positive integer (1-{MaxHoursBack}).");
-        if (hoursBack > MaxHoursBack)
-            return Refusal("hours_back", $"hours_back value '{hoursBack}' exceeds maximum of {MaxHoursBack} hours (7 days). Use a smaller value.");
+            return Refusal("hours_back", $"Invalid hours_back value '{hoursBack}'. Must be a positive integer (1-{maxHours}).");
+        if (hoursBack > maxHours)
+            return Refusal("hours_back", $"hours_back value '{hoursBack}' exceeds maximum of {maxHours} hours{DescribeCeiling(maxHours)}. Use a smaller value.");
         return null;
     }
 
+    /// <summary>The ceiling as days when it is a whole number of them (168 is " (7 days)"), nothing otherwise.</summary>
+    private static string DescribeCeiling(int maxHours) =>
+        maxHours % 24 == 0
+            ? $" ({maxHours / 24} days)"
+            : string.Empty;
+
     /// <summary>
     /// Validates a <c>days_back</c> parameter against the ceiling its tool declares. Returns null if valid, an
     /// error message if invalid — the day-grained twin of <see cref="ValidateHoursBack"/>, in the same sentence
@@ -213,11 +230,19 @@ private static bool IsAsciiBoundary(ReadOnlySpan<char> text, int index) =>
     /// <c>hours_back</c> first, exactly as they were before <c>as_of</c> existed. <paramref name="endUtc"/> is
     /// only meaningful when this returns null.</para>
     /// </summary>
-    public static string? ValidateWindow(int hoursBack, string? asOf, out DateTime endUtc)
+    public static string? ValidateWindow(int hoursBack, string? asOf, out DateTime endUtc) =>
+        ValidateWindow(hoursBack, asOf, MaxHoursBack, out endUtc);
+
+    /// <summary>
+    /// <see cref="ValidateWindow(int, string, out DateTime)"/> with the read's own ceiling (#5562): the opt-in a
+    /// bucketed trend read uses to accept a window past <see cref="MaxHoursBack"/>. Lists and rankings do not call
+    /// this; they stay on the 168-hour overload. Refuses, never clamps.
+    /// </summary>
+    public static string? ValidateWindow(int hoursBack, string? asOf, int maxHours, out DateTime endUtc)
     {
         endUtc = DateTime.UtcNow;
 
-        var hoursError = ValidateHoursBack(hoursBack);
+        var hoursError = ValidateHoursBack(hoursBack, maxHours);
         if (hoursError != null)
         {
             return hoursError;

From a4daccb7825d33896caab71beda5da9bb22a6f05 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:22:32 -0400
Subject: [PATCH 04/33] A query trend past seven days is served from the hourly
 rollup, pinned live (#5562)

---
 .../Darling.Tests/WebReadReachLiveTests.cs    | 154 ++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 Darling/Darling.Tests/WebReadReachLiveTests.cs

diff --git a/Darling/Darling.Tests/WebReadReachLiveTests.cs b/Darling/Darling.Tests/WebReadReachLiveTests.cs
new file mode 100644
index 0000000000..6e77c25e80
--- /dev/null
+++ b/Darling/Darling.Tests/WebReadReachLiveTests.cs
@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * 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.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Npgsql;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Service;
+using PerformanceMonitor.Darling.Storage;
+using Xunit;
+
+namespace Darling.Tests;
+
+/* #1776 own-store: this class mints its own scratch database through ScratchPostgres and never touches another test's
+   rows, so it is deliberately NOT [Collection("live-postgres")] (it also stops the scratch database's TimescaleDB
+   background workers, which the shared store must never inherit). */
+
+/// <summary>
+/// #5562 (lane L4): a query trend asked for through the web dispatch past seven days is served from the hourly rollup
+/// (the Custom Views way: age picks the tier through <c>DurationTrendRouting</c>), and the read's ceiling is the one the
+/// reach table declares. A window of 60 days back holds the rolled-up hour and not the raw rows (a TimescaleDB scratch
+/// store; the raw rows are purged after the rollup refreshes, as retention does at four days).
+/// </summary>
+public sealed class WebReadReachLiveTests
+{
+    private const int ServerId = -556201;
+    private const string ServerName = "a5562-reach-hourly";
+    private const string Db = "ReachDb";
+
+    private static async Task<string> WebReadAsync(NpgsqlDataSource postgres, string read, int hours)
+    {
+        var context = new DefaultHttpContext();
+        context.Request.QueryString = QueryString.Create(new List<KeyValuePair<string, string?>>
+        {
+            new("server_name", ServerName),
+            new("hours_back", hours.ToString(System.Globalization.CultureInfo.InvariantCulture)),
+        });
+        return await DarlingWebEndpoints.BuildReadDispatch()[read](context, postgres, null!);
+    }
+
+    [Fact]
+    public async Task TheDurationTrends_PastSevenDays_ReadTheHourlyRollup_AndRefuseBeyondNinetyDays()
+    {
+        var baseConnectionString = Environment.GetEnvironmentVariable("DARLING_TEST_PG");
+        Assert.SkipWhen(string.IsNullOrEmpty(baseConnectionString),
+            "Set DARLING_TEST_PG to a Postgres connection string (with TimescaleDB installed) to run the live reach test.");
+        var ct = TestContext.Current.CancellationToken;
+
+        await using var scratch = await ScratchPostgres.CreateAsync(baseConnectionString!, ct);
+        await using var connection = new NpgsqlConnection(scratch.ConnectionString);
+        await connection.OpenAsync(ct);
+        await PgMigrations.MigrateAsync(connection, ct);
+
+        var timescaleEnabled = await TimescaleSupport.TryEnableAsync(connection, null, ct);
+        Assert.SkipWhen(!timescaleEnabled, "The live reach test needs TimescaleDB.");
+        await TimescaleSupport.ConvertToHypertablesAsync(connection, null, ct);
+        Assert.True(await TimescaleSupport.EnsureCollectionLogHypertableAsync(connection, null, ct));
+        await using (var stop = new NpgsqlCommand("SELECT _timescaledb_functions.stop_background_workers()", connection))
+        {
+            await stop.ExecuteNonQueryAsync(ct);
+        }
+
+        await DarlingMcpTestData.RegisterServerAsync(connection, ServerId, ServerName, ct);
+        await TimescaleSupport.EnsureContinuousAggregatesAsync(connection, null, ct);
+
+        var bodySucceeded = false;
+        try
+        {
+            /* One busy hour, 60 days back by the wall clock: far past the raw tier's four days, well inside the hourly
+               rollup's ninety. */
+            var now = DateTime.UtcNow;
+            var hour = new DateTime(now.Year, now.Month, now.Day, now.Hour, 0, 0, DateTimeKind.Unspecified).AddDays(-60);
+            var at = hour.AddMinutes(10);
+            await DarlingMcpTestData.ExecAsync(connection, ct,
+                @"INSERT INTO collect.query_stats (collection_id, collection_time, server_id, server_name, database_name, query_hash, sql_handle,
+                      delta_execution_count, delta_worker_time, delta_elapsed_time, delta_logical_reads, total_logical_reads, sample_interval_seconds)
+                  VALUES ($1, $2, $3, $4, $5, '0xQREACH', '0xSQLHREACH', 10, 3600000, 3600000, 100, 1000, 3600)",
+                CollectionIdGenerator.Next(), at, ServerId, ServerName, Db);
+            await DarlingMcpTestData.ExecAsync(connection, ct,
+                @"INSERT INTO collect.procedure_stats (collection_id, collection_time, server_id, server_name, database_name, schema_name, object_name, sql_handle,
+                      delta_execution_count, delta_worker_time, delta_elapsed_time, delta_logical_reads, total_logical_reads, sample_interval_seconds)
+                  VALUES ($1, $2, $3, $4, $5, 'dbo', 'usp_REACH', '0xSQLHREACH', 10, 3600000, 3600000, 100, 1000, 3600)",
+                CollectionIdGenerator.Next(), at, ServerId, ServerName, Db);
+
+            foreach (var view in new[] { TimescaleSupport.QueryStatsIntervalHourlyView, TimescaleSupport.ProcedureStatsIntervalHourlyView })
+            {
+                await using var refresh = new NpgsqlCommand($"CALL refresh_continuous_aggregate('collect.{view}'::regclass, $1::timestamp, $2::timestamp)", connection);
+                refresh.Parameters.AddWithValue(hour.AddHours(-1));
+                refresh.Parameters.AddWithValue(hour.AddHours(2));
+                await refresh.ExecuteNonQueryAsync(ct);
+            }
+
+            foreach (var table in new[] { "collect.query_stats", "collect.procedure_stats" })
+            {
+                await using var purge = new NpgsqlCommand($"DELETE FROM {table} WHERE server_id = $1", connection);
+                purge.Parameters.AddWithValue(ServerId);
+                await purge.ExecuteNonQueryAsync(ct);
+            }
+
+            await using var postgres = NpgsqlDataSource.Create(scratch.ConnectionString);
+
+            foreach (var read in new[] { "get_query_duration_trend", "get_procedure_duration_trend" })
+            {
+                /* 2160 hours is the read's declared reach and reaches the planted hour: the rollup answers, labelled hourly. */
+                var json = await WebReadAsync(postgres, read, WebReadReach.RollupTrendHours);
+                using var doc = JsonDocument.Parse(json);
+                Assert.False(doc.RootElement.TryGetProperty("error", out _), $"{read} refused its own declared reach: {json}");
+                Assert.Equal("hourly", doc.RootElement.GetProperty("source").GetString());
+                var points = doc.RootElement.GetProperty("trend").EnumerateArray().ToArray();
+                Assert.NotEmpty(points);
+                Assert.Contains(points, p => p.GetProperty("elapsed_ms_per_second").GetDouble() > 0);
+
+                /* One hour past the reach is refused, never clamped. */
+                var refused = McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, read, WebReadReach.RollupTrendHours + 1));
+                Assert.Contains("exceeds maximum of 2160 hours (90 days)", refused);
+            }
+
+            /* Query Store's trend takes the same ceiling: 2160 is answered (an empty status is an answer), 2161 is refused. */
+            var qs = await WebReadAsync(postgres, "get_query_store_duration_trend", WebReadReach.RollupTrendHours);
+            Assert.DoesNotContain("exceeds maximum", qs);
+            Assert.Contains("exceeds maximum of 2160 hours (90 days)",
+                McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, "get_query_store_duration_trend", WebReadReach.RollupTrendHours + 1)));
+
+            /* A read that did not opt in keeps 168: a ranking that routes through the same rollup, and a raw-table trend. */
+            foreach (var read in new[] { "get_top_queries_by_cpu", "get_tempdb_trend", "get_query_heatmap", "get_cpu_utilization" })
+            {
+                var refused = McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, read, McpHelpers.MaxHoursBack + 1));
+                Assert.Contains("exceeds maximum of 168 hours (7 days)", refused);
+            }
+
+            bodySucceeded = true;
+        }
+        finally
+        {
+            await LiveStoreCleanup.RunAsync(scratch.ConnectionString, bodySucceeded, async (cleanup, cleanupCt) =>
+            {
+                await using var probe = new NpgsqlCommand(
+                    "SELECT count(*) FROM pg_catalog.pg_stat_activity WHERE datname = pg_catalog.current_database() " +
+                    "AND backend_type LIKE 'TimescaleDB Background Worker Scheduler%'", cleanup);
+                Assert.Equal(0L, Convert.ToInt64(await probe.ExecuteScalarAsync(cleanupCt)));
+            });
+        }
+    }
+}

From 633d2b09e30a98aa30a99069fbdae77648b113b0 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:42:08 -0400
Subject: [PATCH 05/33] The Darling Viewer's time range controls use the shared
 picker (#5562)

---
 .../viewerservertab-eventwires.baseline.txt   |   2 -
 .../ViewerAlertClockCacheTests.cs             |   2 +-
 .../ViewerApplyToAllClockTests.cs             |   2 +-
 .../ViewerTimeRangeWindowTests.cs             | 155 ++++++
 .../ViewerTypedRangeZoneTests.cs              |  66 +--
 .../AlertsHistoryTab.xaml                     |  12 +-
 .../AlertsHistoryTab.xaml.cs                  |  28 +-
 .../FinOpsTab.Loaders.cs                      |  26 +-
 .../FinOpsTab.ObjectHeatmap.cs                |  20 +-
 .../FinOpsTab.xaml                            |  20 +-
 .../FinOpsTab.xaml.cs                         |  12 +
 .../JobHistoryTab.xaml                        |  12 +-
 .../JobHistoryTab.xaml.cs                     |  35 +-
 .../MainWindow.xaml.cs                        |  10 +-
 .../SettingsWindow.xaml                       |  12 +-
 .../SettingsWindow.xaml.cs                    |  25 +-
 .../ViewerDataService.AlertHistory.cs         |  64 ++-
 .../ViewerPreferences.cs                      |  16 +-
 .../ViewerServerTab.ActiveQueries.cs          |   2 +-
 .../ViewerServerTab.Blocking.cs               |   2 +-
 .../ViewerServerTab.Postgres.cs               |   2 +-
 .../ViewerServerTab.Queries.cs                |   6 +-
 .../ViewerServerTab.TimeRange.cs              | 521 +++++-------------
 .../ViewerServerTab.xaml                      |  29 +-
 .../ViewerServerTab.xaml.cs                   |  13 +-
 .../ViewerTimeRangeWindow.cs                  | 143 +++++
 26 files changed, 688 insertions(+), 549 deletions(-)
 create mode 100644 Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs
 create mode 100644 Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs

diff --git a/Darling/Darling.Tests/CapabilityPins/viewerservertab-eventwires.baseline.txt b/Darling/Darling.Tests/CapabilityPins/viewerservertab-eventwires.baseline.txt
index 5df7eba883..666e6ac573 100644
--- a/Darling/Darling.Tests/CapabilityPins/viewerservertab-eventwires.baseline.txt
+++ b/Darling/Darling.Tests/CapabilityPins/viewerservertab-eventwires.baseline.txt
@@ -8,7 +8,6 @@ MouseDoubleClick=>QueryStoreRegressionsGrid_MouseDoubleClick
 SelectionChanged=>AutoRefreshInterval_Changed
 SelectionChanged=>BlockingSubTabs_SelectionChanged
 SelectionChanged=>CompareToCombo_SelectionChanged
-SelectionChanged=>CustomTimeCombo_Changed
 SelectionChanged=>FileIoSubTabs_SelectionChanged
 SelectionChanged=>HeatmapMetric_SelectionChanged
 SelectionChanged=>InnerTabs_SelectionChanged
@@ -19,5 +18,4 @@ SelectionChanged=>QueryStatsGrid_SelectionChanged
 SelectionChanged=>QueryStoreGrid_SelectionChanged
 SelectionChanged=>SystemEventsSubTabs_SelectionChanged
 SelectionChanged=>TimeDisplayMode_SelectionChanged
-SelectionChanged=>TimeRangeCombo_SelectionChanged
 SelectionChanged=>WaitStatsMetric_SelectionChanged
diff --git a/Darling/Darling.Tests/ViewerAlertClockCacheTests.cs b/Darling/Darling.Tests/ViewerAlertClockCacheTests.cs
index 33e1cb6762..453d3121a0 100644
--- a/Darling/Darling.Tests/ViewerAlertClockCacheTests.cs
+++ b/Darling/Darling.Tests/ViewerAlertClockCacheTests.cs
@@ -142,7 +142,7 @@ public void TheAlertHistoryReadTakesItsClocksFromTheCache_NotFromTheStoreEveryCa
         var alertHistory = ViewerCode("ViewerDataService.AlertHistory.cs");
         var method = Regex.Match(
             alertHistory,
-            @"public async Task<List<ViewerAlertRow>> GetAlertHistoryAsync\(.*?\n    \}\n",
+            @"public async Task<List<ViewerAlertRow>> GetAlertHistoryWindowAsync\(.*?\n    \}\n",
             RegexOptions.Singleline);
 
         Assert.True(method.Success);
diff --git a/Darling/Darling.Tests/ViewerApplyToAllClockTests.cs b/Darling/Darling.Tests/ViewerApplyToAllClockTests.cs
index f2e8583f5e..806c1d039d 100644
--- a/Darling/Darling.Tests/ViewerApplyToAllClockTests.cs
+++ b/Darling/Darling.Tests/ViewerApplyToAllClockTests.cs
@@ -61,7 +61,7 @@ public void ThePlaceThatBroadcastsTheRange_SkipsOnlyTheSource_AndASelectedTabRel
         var selection = Member("MainWindow.xaml.cs", "MainTabs_SelectionChanged");
         var load = Member("MainWindow.xaml.cs", "LoadVisibleTabAsync");
 
-        Assert.Contains("ApplyExternalTimeRange(index, customFromUtc, customToUtc)", broadcast);
+        Assert.Contains("ApplyExternalTimeRange(range)", broadcast);
         Assert.Contains("!ReferenceEquals(serverTab, source)", broadcast);
         Assert.Contains("await RefreshVisibleAsync()", selection);
         Assert.Matches(@"case\s+TabItem\s*\{\s*Content:\s*ViewerServerTab\s+serverTab\s*\}\s*:\s*await\s+serverTab\.RefreshActiveInnerTabAsync\(\)", load);
diff --git a/Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs b/Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs
new file mode 100644
index 0000000000..058d1c2083
--- /dev/null
+++ b/Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using PerformanceMonitor.Darling.Viewer;
+using PerformanceMonitor.Ui;
+using Xunit;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// #5562: the Viewer's side of the shared time range picker. <see cref="ViewerTimeRangeWindow"/> is the pure core: the
+/// window a held range reads, the whole hours the few integer readers take, the legacy preference index, what Apply to
+/// All sends, and the cadence note. (A ViewerServerTab needs the app's resources, so the rules are pinned here.)
+/// </summary>
+public sealed class ViewerTimeRangeWindowTests
+{
+    private static readonly DateTime Now = new(2026, 10, 8, 15, 0, 0, DateTimeKind.Unspecified);
+    private static readonly TimeZoneInfo Eastern = TimeZoneInfo.FindSystemTimeZoneById("America/New_York");
+
+    [Theory]
+    [InlineData(0, "1h")]
+    [InlineData(1, "4h")]
+    [InlineData(2, "12h")]
+    [InlineData(3, "1d")]
+    [InlineData(4, "1w")]
+    [InlineData(5, "1d")]
+    [InlineData(-1, "1d")]
+    public void LegacyIndex_MapsToTheRangeItAlwaysMeant(int index, string expectedId)
+    {
+        Assert.Equal(expectedId, ViewerTimeRangeWindow.FromLegacyIndex(index).Id);
+    }
+
+    [Fact]
+    public void ACalendarPeriod_FlowsThroughTheWindow_InTheDisplayZone()
+    {
+        var (start, end, live) = ViewerTimeRangeWindow.Window(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), Now, Eastern);
+
+        Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), start);   // local midnight, EDT
+        Assert.Equal(Now, end);
+        Assert.True(live);
+    }
+
+    [Fact]
+    public void AFinishedPeriod_KeepsItsInstants_AndIsNotLive()
+    {
+        var (start, end, live) = ViewerTimeRangeWindow.Window(TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday), Now, Eastern);
+
+        Assert.Equal(new DateTime(2026, 10, 7, 4, 0, 0), start);
+        Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), end);
+        Assert.False(live);
+    }
+
+    [Theory]
+    [InlineData(5, 1)]
+    [InlineData(45, 1)]
+    [InlineData(60, 1)]
+    [InlineData(61, 2)]
+    [InlineData(24 * 60, 24)]
+    public void ASubHourSpan_FlowsThroughTheWindow_AndRoundsUpToWholeHoursOnlyForTheIntegerReaders(int minutes, int expectedHours)
+    {
+        var (start, end, _) = ViewerTimeRangeWindow.Window(TimeRangeSpec.Relative(TimeSpan.FromMinutes(minutes)), Now, Eastern);
+
+        Assert.Equal(TimeSpan.FromMinutes(minutes), end - start);
+        Assert.Equal(expectedHours, ViewerTimeRangeWindow.HoursBack(start, end));
+    }
+
+    [Fact]
+    public void ARangeThatCannotResolveYet_FallsBackToTwentyFourHours()
+    {
+        // Midnight plus one minute: Today is under the 5-minute floor.
+        var justAfterMidnight = new DateTime(2026, 10, 8, 4, 1, 0, DateTimeKind.Unspecified);
+        var (start, end, live) = ViewerTimeRangeWindow.Window(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), justAfterMidnight, Eastern);
+
+        Assert.Equal(TimeSpan.FromHours(24), end - start);
+        Assert.True(live);
+    }
+
+    [Fact]
+    public void ApplyToAll_SendsACalendarPeriodAsTheInstantsItNames_AndLeavesARollingRangeAlone()
+    {
+        var rolling = TimeRangeSpec.Relative(TimeSpan.FromHours(4));
+        Assert.Same(rolling, ViewerTimeRangeWindow.ForBroadcast(rolling, Now, Eastern));
+
+        var today = ViewerTimeRangeWindow.ForBroadcast(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), Now, Eastern);
+        Assert.Equal(TimeRangeKind.Since, today.Kind);
+        Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), today.StartUtc);
+
+        var yesterday = ViewerTimeRangeWindow.ForBroadcast(TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday), Now, Eastern);
+        Assert.Equal(TimeRangeKind.Fixed, yesterday.Kind);
+        Assert.Equal(new DateTime(2026, 10, 7, 4, 0, 0), yesterday.StartUtc);
+        Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), yesterday.EndUtc);
+    }
+
+    [Fact]
+    public void Preferences_LegacyIndexOnly_MapsToTheNewStringId()
+    {
+        var prefs = new ViewerPreferences { DefaultTimeRangeIndex = 4 }.Normalize();
+
+        Assert.Equal("1w", prefs.DefaultTimeRange);
+        Assert.Equal(4, prefs.DefaultTimeRangeIndex);
+    }
+
+    [Fact]
+    public void Preferences_APeriodId_WinsOverTheLegacyIndex_AndAFixedRangeIsNeverKept()
+    {
+        var period = new ViewerPreferences { DefaultTimeRange = "previous-week", DefaultTimeRangeIndex = 0 }.Normalize();
+        Assert.Equal("previous-week", period.DefaultTimeRange);
+        Assert.Equal(3, period.DefaultTimeRangeIndex);   // the nearest the legacy combo could hold: its default
+
+        var fixedRange = new ViewerPreferences
+        {
+            DefaultTimeRange = "fixed:2026-10-01T04:00:00Z/2026-10-02T04:00:00Z",
+            DefaultTimeRangeIndex = 1,
+        }.Normalize();
+        Assert.Equal("4h", fixedRange.DefaultTimeRange);
+
+        var unknown = new ViewerPreferences { DefaultTimeRange = "nonsense" }.Normalize();
+        Assert.Equal("1d", unknown.DefaultTimeRange);
+    }
+
+    [Theory]
+    [InlineData("Overview", "cpu_utilization")]
+    [InlineData("Wait Stats", "wait_stats")]
+    [InlineData("Queries", "query_stats")]
+    [InlineData("Plan Viewer", null)]
+    public void TheMainCollector_IsNamedByTheInnerTab(string header, string? expected)
+    {
+        Assert.Equal(expected, ViewerTimeRangeWindow.MainCollectorFor(header));
+    }
+
+    [Fact]
+    public void TheSampleInterval_IsTheShippedCadence_WhenNothingOverridesIt()
+    {
+        Assert.Equal(TimeSpan.FromMinutes(1), ViewerTimeRangeWindow.SampleIntervalFor("wait_stats", 7, Array.Empty<CollectorScheduleRow>()));
+        Assert.Null(ViewerTimeRangeWindow.SampleIntervalFor(null, 7, null));
+        Assert.Null(ViewerTimeRangeWindow.SampleIntervalFor("not_a_collector", 7, null));
+    }
+
+    [Fact]
+    public void ADataStart_ShowsTheNoteOnThePicker_OnlyWhenTheRangeStartsWellBeforeIt()
+    {
+        var range = TimeRangeSpec.Relative(TimeSpan.FromDays(2));
+        Assert.True(range.TryResolve(Now, Eastern, out var resolved, out _));
+
+        Assert.NotNull(TimeRangeNotes.DataStartNote(resolved!, Now.AddHours(-3)));
+        Assert.Null(TimeRangeNotes.DataStartNote(resolved!, Now.AddDays(-3)));
+    }
+}
diff --git a/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs b/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs
index 83290771ad..b786bdf7e5 100644
--- a/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs
+++ b/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs
@@ -202,71 +202,73 @@ public void ChoosingAPreset_HoldsNothing()
         Assert.Null(range.Render(ServerZone));
     }
 
-    /* ---- source pins: the tab reaches the range only through the held instants ---- */
+    /* ---- source pins: the tab holds the range in the shared picker and draws it in its own zone (#5562) ---- */
 
     [Fact]
-    public void GetCustomRangeUtc_ReturnsTheHeldPair_AndDoesNotParseThePickers()
+    public void TheWindowIsReadFromThePickersHeldRange_NotFromControlsThatParseText()
     {
-        var body = StripComments(MemberText(TabSource(), "GetCustomRangeUtc"));
+        var body = StripComments(MemberText(TabSource(), "GetWindowUtc"));
 
+        Assert.Contains("ViewerTimeRangeWindow.Window(RangePicker.Value", body);
         Assert.DoesNotContain("DisplayToNaiveUtc", body);
         Assert.DoesNotContain("ConvertFromDisplay", body);
-        Assert.DoesNotContain("GetDateTimeFromPickers", body);
-        Assert.Contains("_customRange", body);
     }
 
     [Fact]
-    public void TheDisplayModeSwitch_ParsesNothing_AndDrawsTheHeldRangeInTheNewZone()
+    public void TheDisplayModeSwitch_ParsesNothing_AndRedrawsThePickerInTheNewZone()
     {
         var body = StripComments(MemberText(TabSource(), "TimeDisplayMode_SelectionChanged"));
 
         Assert.DoesNotContain("DisplayToNaiveUtc", body);
         Assert.DoesNotContain("ConvertFromDisplay", body);
-        Assert.DoesNotContain("GetDateTimeFromPickers", body);
         Assert.DoesNotContain("ForDisplay", body);
-        Assert.Contains("RenderCustomRange(", body);
-        Assert.Contains("DisplayZoneFor(mode,", body);
+        Assert.Contains("RefreshRangePicker()", body);
     }
 
     [Theory]
-    [InlineData("ApplyExternalTimeRange", "_customRange.Set(")]
-    [InlineData("ApplyExternalTimeRange", "_customRange.Clear()")]
-    [InlineData("SetToolbarWindowUtc", "_customRange.Set(")]
-    [InlineData("TimeRangeCombo_SelectionChanged", "_customRange.Clear()")]
-    [InlineData("TimeRangeCombo_SelectionChanged", "HoldPickersAsRange(")]
-    [InlineData("ApplyPickerEdit", "_customRange.ApplyEdit(")]
-    public void EveryPlaceThatSetsThePickers_HoldsTheRange(string member, string expected)
+    [InlineData("ApplyExternalTimeRange", "RangePicker.Value = range")]
+    [InlineData("SetToolbarWindowUtc", "TimeRangeSpec.FixedRange(fromUtc, toUtc)")]
+    [InlineData("InitializeRangePicker", "RangePicker.Value = ViewerTimeRangeWindow.DefaultFor(preferences)")]
+    [InlineData("InitializeRangePicker", "RangePicker.ZoneProvider = () => TabDisplayZone")]
+    public void EveryPlaceThatSetsThePicker_HoldsTheRangeAndTheTabsZone(string member, string expected)
     {
         Assert.Contains(expected, StripComments(MemberText(TabSource(), member)));
     }
 
     [Theory]
-    [InlineData("ApplyExternalTimeRange")]
-    [InlineData("SetToolbarWindowUtc")]
-    [InlineData("ApplyPickerEdit")]
     [InlineData("SetDisplayModeSelection")]
     [InlineData("RefreshServerClockAsync")]
-    public void EveryPlaceThatMovesTheZoneOrTheRange_DrawsThePickersFromTheHeldRange(string member)
+    public void EveryPlaceThatMovesTheZone_RedrawsThePicker(string member)
     {
-        Assert.Contains("RenderCustomRange(", StripComments(MemberText(TabSource(), member)));
+        Assert.Contains("RefreshRangePicker()", StripComments(MemberText(TabSource(), member)));
     }
 
     [Fact]
-    public void ThePickersAreWrittenOnlyByTheDrawing_AndTheDefaultSeed()
+    public void TheOverviewLanesAlwaysGetTheExplicitWindow_SoASubHourSpanIsNotRoundedToHours()
     {
-        var source = StripComments(TabSource());
-        var rendering = StripComments(MemberText(TabSource(), "RenderCustomRange"));
-        var comboSetup = StripComments(MemberText(TabSource(), "InitializeTimeComboBoxes"));
-        var seed = StripComments(MemberText(TabSource(), "TimeRangeCombo_SelectionChanged"));
+        var body = StripComments(MemberText(TabSource(), "GetOverviewCustomRange"));
 
-        var setters = new Regex(@"\b(?:From|To)(?:DatePicker\.SelectedDate|HourCombo\.SelectedIndex|MinuteCombo\.SelectedIndex)\s*=(?!=)");
-        var total = setters.Matches(source).Count;
-        var allowed = setters.Matches(rendering).Count + setters.Matches(comboSetup).Count + setters.Matches(seed).Count;
+        Assert.Contains("GetWindowUtc()", body);
+        Assert.DoesNotContain("(null, null)", body);
+    }
 
-        Assert.Equal(allowed, total);
-        Assert.Equal(6, setters.Matches(rendering).Count);
+    [Fact]
+    public void TheDataStartNote_IsFedByTheProbeThePrimarySurfacesAlreadyAwait()
+    {
+        var body = StripComments(MemberText(TabSource(), "PrimaryDataStartAsync"));
+
+        Assert.Contains("DataStartOrNullAsync(probe, surface)", body);
+        Assert.Contains("RecordDataStart(floor)", body);
+        Assert.Contains("RangePicker.DataStartUtc = floor", StripComments(MemberText(TabSource(), "RecordDataStart")));
+        foreach (var file in new[] { "ViewerServerTab.Queries.cs", "ViewerServerTab.ActiveQueries.cs", "ViewerServerTab.Blocking.cs" })
+        {
+            Assert.Contains("PrimaryDataStartAsync(", ViewerSource(file, ThisFile()));
+        }
     }
 
+    private static string ThisFile([CallerFilePath] string thisFile = "") => thisFile;
+
+
     /* ---- helpers ---- */
 
     private static string TabSource([CallerFilePath] string thisFile = "") => ViewerSource("ViewerServerTab.TimeRange.cs", thisFile);
@@ -465,7 +467,7 @@ public void AlertHistory_ReadsTheClocksOncePerLoad_AndStampsEachRow()
     {
         var source = ViewerTypedRangeTests.ViewerSource("ViewerDataService.AlertHistory.cs", ThisFile());
         var display = ViewerTypedRangeTests.StripComments(ViewerTypedRangeTests.MemberText(source, "TimeLocal"));
-        var load = ViewerTypedRangeTests.StripComments(ViewerTypedRangeTests.MemberText(source, "GetAlertHistoryAsync"));
+        var load = ViewerTypedRangeTests.StripComments(ViewerTypedRangeTests.MemberText(source, "GetAlertHistoryWindowAsync"));
 
         /* The active-clock ForDisplay by its exact name: FormatForDisplay is the renderer that takes the row's zone (#4766). */
         Assert.DoesNotMatch(@"\bForDisplay\b", display);
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml
index 8096544cc1..c87a509724 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml
@@ -3,6 +3,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:ui="clr-namespace:PerformanceMonitor.Ui;assembly=PerformanceMonitor.Ui"
              mc:Ignorable="d"
              d:DesignHeight="450" d:DesignWidth="800">
     <!-- The full Alert History surface (W2a viewer copy-parity), copied from Lite's
@@ -81,14 +82,9 @@
                        Foreground="{DynamicResource ForegroundBrush}"/>
             <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="5,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
-            <ComboBox x:Name="TimeRangeComboBox" Width="100" VerticalAlignment="Center"
-                      SelectionChanged="TimeRangeComboBox_SelectionChanged">
-                <ComboBoxItem Content="Last 1 Hour" Tag="1"/>
-                <ComboBoxItem Content="Last 4 Hours" Tag="4"/>
-                <ComboBoxItem Content="Last 24 Hours" Tag="24" IsSelected="True"/>
-                <ComboBoxItem Content="Last 7 Days" Tag="168"/>
-                <ComboBoxItem Content="All" Tag="8760"/>
-            </ComboBox>
+            <!-- #5562: the shared time range picker. The old "All" (8760 hours) is a typed range now ("365d"). -->
+            <ui:TimeRangePicker x:Name="TimeRangePickerControl" Compact="True" VerticalAlignment="Center"
+                                RangeChanged="TimeRangePicker_RangeChanged"/>
             <TextBlock Text="Server:" VerticalAlignment="Center" Margin="12,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
             <ComboBox x:Name="ServerFilterComboBox" Width="160" VerticalAlignment="Center"
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs
index 4a6f8e1cb1..e63ce10cf9 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs
@@ -62,6 +62,9 @@ public partial class AlertsHistoryTab : UserControl
     public AlertsHistoryTab()
     {
         InitializeComponent();
+        /* #5562: the shared picker; the old combo defaulted to the last 24 hours. */
+        TimeRangePickerControl.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
+        TimeRangePickerControl.Value = TimeRangePresets.Find("1d")!;
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
@@ -99,11 +102,10 @@ private async Task LoadAlertsAsync()
 
         try
         {
-            var hoursBack = GetSelectedHoursBack();
+            var (sinceUtc, untilUtc, isLive) = GetSelectedWindow();
             int? serverId = GetSelectedServerId();
-            var sinceUtc = DateTime.UtcNow.AddHours(-hoursBack);
 
-            var alerts = await _dataService.GetAlertHistoryAsync(sinceUtc, serverId, RowCap);
+            var alerts = await _dataService.GetAlertHistoryWindowAsync(sinceUtc, isLive ? null : untilUtc, serverId, RowCap);
 
             if (_filterManager != null)
             {
@@ -192,13 +194,16 @@ private void PopulateServerFilter(List<ViewerAlertRow> alerts)
         ServerFilterComboBox.SelectionChanged += ServerFilterComboBox_SelectionChanged;
     }
 
+    /// <summary>The picker's window now (#5562): start, end and whether the end slides with now. Both the grid read and
+    /// Dismiss All use it, so Dismiss All touches exactly the rows the grid shows.</summary>
+    private (DateTime StartUtc, DateTime EndUtc, bool IsLive) GetSelectedWindow()
+        => ViewerTimeRangeWindow.Window(TimeRangePickerControl.Value, DateTime.UtcNow, ViewerTimeHelper.CurrentDisplayZone());
+
+    /// <summary>The window's span as whole hours back (at least one), for the dismissal log line.</summary>
     private int GetSelectedHoursBack()
     {
-        if (TimeRangeComboBox.SelectedItem is ComboBoxItem item && item.Tag is string tagStr)
-        {
-            return int.TryParse(tagStr, out var hours) ? hours : 24;
-        }
-        return 24;
+        var (startUtc, endUtc, _) = GetSelectedWindow();
+        return ViewerTimeRangeWindow.HoursBack(startUtc, endUtc);
     }
 
     private int? GetSelectedServerId()
@@ -287,7 +292,7 @@ private void UpdateStaleDataIndicator()
 
     #region Event Handlers
 
-    private async void TimeRangeComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    private async void TimeRangePicker_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (IsLoaded)
         {
@@ -373,8 +378,9 @@ private async void DismissAll_Click(object sender, RoutedEventArgs e)
         {
             var hoursBack = GetSelectedHoursBack();
             int? serverId = GetSelectedServerId();
-            var sinceUtc = DateTime.UtcNow.AddHours(-hoursBack);
-            var affected = await _dataService.DismissAllVisibleAlertsAsync(sinceUtc, serverId);
+            /* The same window the grid read (#5562): a range that ended in the past dismisses only the rows up to its end. */
+            var (sinceUtc, untilUtc, isLive) = GetSelectedWindow();
+            var affected = await _dataService.DismissAllVisibleAlertsWindowAsync(sinceUtc, isLive ? null : untilUtc, serverId);
             if (LogDismissals)
             {
                 var scope = serverId.HasValue ? $"server {serverId.Value}" : "all servers";
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
index 03557f8ba8..b7917a53ec 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
@@ -377,13 +377,21 @@ private static void SetBar(Border bar, ColumnDefinition filled, ColumnDefinition
         empty.Width = new GridLength(Math.Max(100 - clamped, 0.1), GridUnitType.Star);
     }
 
-    private static int HoursBackFromIndex(ComboBox combo) => combo.SelectedIndex switch { 0 => 1, 1 => 4, 2 => 12, 3 => 24, 4 => 168, _ => 24 };
+    /// <summary>The hours-back a FinOps list reads for its picker (#5562): whole hours from the range's start to now, rounded
+    /// up, at least one. These reads take "hours back from now", so a span under an hour reads as one hour, and a range that
+    /// ended in the past reads everything since its start (<see cref="ViewerTimeRangeWindow.HoursBack"/>).</summary>
+    private static int HoursBackFromPicker(TimeRangePicker picker)
+    {
+        var now = DateTime.UtcNow;
+        var (startUtc, _, _) = ViewerTimeRangeWindow.Window(picker.Value, now, ViewerTimeHelper.CurrentDisplayZone());
+        return ViewerTimeRangeWindow.HoursBack(startUtc, now);
+    }
 
     // ── Database Resources ──
 
     private async Task LoadFinOpsDatabaseResourcesAsync()
     {
-        var hoursBack = HoursBackFromIndex(FinOpsResourceUsageTimeRangeCombo);
+        var hoursBack = HoursBackFromPicker(FinOpsResourceUsageTimeRangeCombo);
         var data = await _dataService.GetDatabaseResourceUsageAsync(_server.ServerId, hoursBack);
         _finopsDbResourcesFilterMgr!.UpdateData(data);
         FinOpsNoDatabaseResourcesMessage.Visibility = data.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
@@ -487,7 +495,7 @@ private async Task LoadFinOpsApplicationConnectionsAsync()
 
     private async Task LoadFinOpsHighImpactAsync()
     {
-        var hoursBack = HoursBackFromIndex(FinOpsHighImpactTimeRangeCombo);
+        var hoursBack = HoursBackFromPicker(FinOpsHighImpactTimeRangeCombo);
         var data = await _dataService.GetHighImpactQueriesAsync(_server.ServerId, hoursBack);
         _finopsHighImpactFilterMgr!.UpdateData(data);
         FinOpsHighImpactNoDataMessage.Visibility = data.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
@@ -526,7 +534,7 @@ private async Task LoadFinOpsTempdbSummaryAsync()
 
     private async Task LoadFinOpsWaitCategorySummaryAsync()
     {
-        var hoursBack = HoursBackFromIndex(FinOpsWaitStatsTimeRangeCombo);
+        var hoursBack = HoursBackFromPicker(FinOpsWaitStatsTimeRangeCombo);
         var data = await _dataService.GetWaitCategorySummaryAsync(_server.ServerId, hoursBack);
 
         /* Proportional cost share scaled to the window (mirrors Lite: the monthly budget scaled by the window hours). */
@@ -547,7 +555,7 @@ private async Task LoadFinOpsWaitCategorySummaryAsync()
 
     private async Task LoadFinOpsExpensiveQueriesAsync()
     {
-        var hoursBack = HoursBackFromIndex(FinOpsExpensiveQueriesTimeRangeCombo);
+        var hoursBack = HoursBackFromPicker(FinOpsExpensiveQueriesTimeRangeCombo);
         var data = await _dataService.GetExpensiveQueriesAsync(_server.ServerId, hoursBack);
 
         /* Proportional cost share scaled to the window (mirrors Lite: the monthly budget scaled by the window hours). */
@@ -643,25 +651,25 @@ private async void FinOpsShowRemoved_Changed(object sender, RoutedEventArgs e)
     }
     private async void FinOpsOptimizationRefresh_Click(object sender, RoutedEventArgs e) => await RunFinOpsLoad(LoadFinOpsOptimizationAsync);
 
-    private async void FinOpsResourceUsageTimeRange_Changed(object sender, SelectionChangedEventArgs e)
+    private async void FinOpsResourceUsageTimeRange_Changed(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded) return;
         await RunFinOpsLoad(LoadFinOpsDatabaseResourcesAsync);
     }
 
-    private async void FinOpsWaitStatsTimeRange_Changed(object sender, SelectionChangedEventArgs e)
+    private async void FinOpsWaitStatsTimeRange_Changed(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded) return;
         await RunFinOpsLoad(LoadFinOpsWaitCategorySummaryAsync);
     }
 
-    private async void FinOpsExpensiveQueriesTimeRange_Changed(object sender, SelectionChangedEventArgs e)
+    private async void FinOpsExpensiveQueriesTimeRange_Changed(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded) return;
         await RunFinOpsLoad(LoadFinOpsExpensiveQueriesAsync);
     }
 
-    private async void FinOpsHighImpactTimeRange_Changed(object sender, SelectionChangedEventArgs e)
+    private async void FinOpsHighImpactTimeRange_Changed(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded) return;
         await RunFinOpsLoad(LoadFinOpsHighImpactAsync);
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs
index 636d0e463e..d13a018e96 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs
@@ -44,13 +44,19 @@ private enum FinOpsStorageDrillLevel { Parent, Objects, Indexes }
     private TextBlock? _finopsObjHeatmapPopupText;
     private DateTime _finopsLastObjHeatmapHover;
 
-    private int GetFinOpsObjectHeatmapDaysBack() => FinOpsObjectHeatmapWindowCombo?.SelectedIndex switch
+    /// <summary>Whole days back for the object heatmap (#5562): the picker's range start to now, rounded up, at least one day.
+    /// The old combo offered 7, 30 and 90 days; the picker's "1mo" is 30, and any other length is typed.</summary>
+    private int GetFinOpsObjectHeatmapDaysBack()
     {
-        0 => 7,
-        1 => 30,
-        2 => 90,
-        _ => 30
-    };
+        if (FinOpsObjectHeatmapWindowCombo is null)
+        {
+            return 30;
+        }
+
+        var now = DateTime.UtcNow;
+        var (startUtc, _, _) = ViewerTimeRangeWindow.Window(FinOpsObjectHeatmapWindowCombo.Value, now, ViewerTimeHelper.CurrentDisplayZone());
+        return Math.Max(1, (int)Math.Ceiling((now - startUtc).TotalDays));
+    }
 
     /// <summary>Refresh-aware load: reloads whichever drill level is currently showing (server tab timer / Refresh).</summary>
     private async Task LoadFinOpsStorageGrowthActiveAsync()
@@ -131,7 +137,7 @@ private void FinOpsStorageGrowthBack_Click(object sender, RoutedEventArgs e)
             ShowFinOpsStorageView(FinOpsStorageDrillLevel.Parent);
     }
 
-    private async void FinOpsObjectHeatmapWindow_Changed(object sender, SelectionChangedEventArgs e)
+    private async void FinOpsObjectHeatmapWindow_Changed(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded) return;
         if (_finopsStorageLevel != FinOpsStorageDrillLevel.Objects || string.IsNullOrEmpty(_finopsObjDrillDb)) return;
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml
index 1627e6f189..ff94020c0a 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml
@@ -504,9 +504,7 @@
                         <Grid.RowDefinitions><RowDefinition Height="Auto"/><RowDefinition Height="*"/></Grid.RowDefinitions>
                         <StackPanel Grid.Row="0" Orientation="Horizontal" Margin="10,8" Height="36">
                             <TextBlock Text="Database Resource Usage" VerticalAlignment="Center" Margin="0,0,10,0" FontWeight="Bold" FontSize="14" Foreground="{DynamicResource ForegroundBrush}"/>
-                            <ComboBox x:Name="FinOpsResourceUsageTimeRangeCombo" SelectedIndex="3" Width="120" Margin="0,0,8,0" SelectionChanged="FinOpsResourceUsageTimeRange_Changed">
-                                <ComboBoxItem Content="Last 1 hour"/><ComboBoxItem Content="Last 4 hours"/><ComboBoxItem Content="Last 12 hours"/><ComboBoxItem Content="Last 24 hours"/><ComboBoxItem Content="Last 7 days"/>
-                            </ComboBox>
+                            <ui:TimeRangePicker x:Name="FinOpsResourceUsageTimeRangeCombo" Compact="True" VerticalAlignment="Center" RangeChanged="FinOpsResourceUsageTimeRange_Changed"/>
                             <Button Content="Refresh" Click="FinOpsRefreshDatabaseResources_Click" Margin="4,0,0,0" Padding="10,4" MinWidth="70"/>
                             <TextBlock x:Name="FinOpsDbResourcesCountIndicator" Text="" Margin="12,0,0,0" VerticalAlignment="Center" FontStyle="Italic" Foreground="{DynamicResource AccentBrush}" FontWeight="SemiBold"/>
                         </StackPanel>
@@ -541,9 +539,7 @@
                             <Button Content="Refresh" Click="FinOpsRefreshStorageGrowth_Click" Margin="12,0,0,0" Padding="10,4" MinWidth="70"/>
                             <TextBlock x:Name="FinOpsStorageGrowthCountIndicator" Text="" Margin="12,0,0,0" VerticalAlignment="Center" FontStyle="Italic" Foreground="{DynamicResource AccentBrush}" FontWeight="SemiBold"/>
                             <TextBlock Text="Window:" VerticalAlignment="Center" Margin="16,0,6,0" FontSize="11" x:Name="FinOpsObjectHeatmapWindowLabel" Visibility="Collapsed" Foreground="{DynamicResource ForegroundMutedBrush}"/>
-                            <ComboBox x:Name="FinOpsObjectHeatmapWindowCombo" Visibility="Collapsed" SelectedIndex="1" Width="120" FontSize="11" Padding="4,2" SelectionChanged="FinOpsObjectHeatmapWindow_Changed">
-                                <ComboBoxItem Content="Last 7 days"/><ComboBoxItem Content="Last 30 days"/><ComboBoxItem Content="Last 90 days"/>
-                            </ComboBox>
+                            <ui:TimeRangePicker x:Name="FinOpsObjectHeatmapWindowCombo" Compact="True" Visibility="Collapsed" VerticalAlignment="Center" RangeChanged="FinOpsObjectHeatmapWindow_Changed"/>
                         </StackPanel>
                         <Grid Grid.Row="1" Margin="10,0,10,10">
                             <Grid x:Name="FinOpsStorageParentView">
@@ -797,9 +793,7 @@
                                         <StackPanel Orientation="Horizontal">
                                             <TextBlock Text="Wait Stats Summary" VerticalAlignment="Center"/>
                                             <TextBlock Text="  Time Range:" VerticalAlignment="Center" Margin="12,0,4,0" FontSize="11"/>
-                                            <ComboBox x:Name="FinOpsWaitStatsTimeRangeCombo" SelectedIndex="3" Width="120" FontSize="11" SelectionChanged="FinOpsWaitStatsTimeRange_Changed">
-                                                <ComboBoxItem Content="Last 1 hour"/><ComboBoxItem Content="Last 4 hours"/><ComboBoxItem Content="Last 12 hours"/><ComboBoxItem Content="Last 24 hours"/><ComboBoxItem Content="Last 7 days"/>
-                                            </ComboBox>
+                                            <ui:TimeRangePicker x:Name="FinOpsWaitStatsTimeRangeCombo" Compact="True" VerticalAlignment="Center" RangeChanged="FinOpsWaitStatsTimeRange_Changed"/>
                                         </StackPanel>
                                     </Expander.Header>
                                     <StackPanel>
@@ -824,9 +818,7 @@
                                         <StackPanel Orientation="Horizontal">
                                             <TextBlock Text="Expensive Queries (Top 20 by CPU)" VerticalAlignment="Center"/>
                                             <TextBlock Text="  Time Range:" VerticalAlignment="Center" Margin="12,0,4,0" FontSize="11"/>
-                                            <ComboBox x:Name="FinOpsExpensiveQueriesTimeRangeCombo" SelectedIndex="3" Width="120" FontSize="11" SelectionChanged="FinOpsExpensiveQueriesTimeRange_Changed">
-                                                <ComboBoxItem Content="Last 1 hour"/><ComboBoxItem Content="Last 4 hours"/><ComboBoxItem Content="Last 12 hours"/><ComboBoxItem Content="Last 24 hours"/><ComboBoxItem Content="Last 7 days"/>
-                                            </ComboBox>
+                                            <ui:TimeRangePicker x:Name="FinOpsExpensiveQueriesTimeRangeCombo" Compact="True" VerticalAlignment="Center" RangeChanged="FinOpsExpensiveQueriesTimeRange_Changed"/>
                                         </StackPanel>
                                     </Expander.Header>
                                     <StackPanel>
@@ -880,9 +872,7 @@
                             <TextBlock Text="High Impact Queries" VerticalAlignment="Center" Margin="0,0,10,0" FontWeight="Bold" FontSize="14" Foreground="{DynamicResource ForegroundBrush}"/>
                             <Button Content="Refresh" Click="FinOpsRefreshHighImpact_Click" Margin="12,0,0,0" Padding="10,4" MinWidth="70"/>
                             <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="16,0,4,0" FontSize="11" Foreground="{DynamicResource ForegroundBrush}"/>
-                            <ComboBox x:Name="FinOpsHighImpactTimeRangeCombo" SelectedIndex="3" Width="120" FontSize="11" SelectionChanged="FinOpsHighImpactTimeRange_Changed">
-                                <ComboBoxItem Content="Last 1 hour"/><ComboBoxItem Content="Last 4 hours"/><ComboBoxItem Content="Last 12 hours"/><ComboBoxItem Content="Last 24 hours"/><ComboBoxItem Content="Last 7 days"/>
-                            </ComboBox>
+                            <ui:TimeRangePicker x:Name="FinOpsHighImpactTimeRangeCombo" Compact="True" VerticalAlignment="Center" RangeChanged="FinOpsHighImpactTimeRange_Changed"/>
                             <TextBlock x:Name="FinOpsHighImpactCountIndicator" VerticalAlignment="Center" Margin="12,0,0,0" FontStyle="Italic" Foreground="{DynamicResource AccentBrush}" FontWeight="SemiBold"/>
                         </StackPanel>
                         <TextBlock x:Name="FinOpsHighImpactNoDataMessage" Grid.Row="1" Text="No high-impact queries found for this time range." Margin="10,0" Visibility="Collapsed" Foreground="{DynamicResource ForegroundMutedBrush}" FontStyle="Italic"/>
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs
index 414375860f..f59e5e53d8 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs
@@ -57,6 +57,18 @@ public FinOpsTab()
     {
         InitializeComponent();
 
+        /* #5562: the shared time range pickers. The old combos opened on 24 hours (the heatmap on 30 days); the pickers
+           open on the same, drawn in the display zone in force. */
+        foreach (var picker in new[] { FinOpsResourceUsageTimeRangeCombo, FinOpsWaitStatsTimeRangeCombo,
+                     FinOpsExpensiveQueriesTimeRangeCombo, FinOpsHighImpactTimeRangeCombo })
+        {
+            picker.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
+            picker.Value = TimeRangePresets.Find("1d")!;
+        }
+
+        FinOpsObjectHeatmapWindowCombo.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
+        FinOpsObjectHeatmapWindowCombo.Value = TimeRangePresets.Find("1mo")!;
+
         /* Register the FinOps grids' column-filter managers into _filterManagers (defined below), after
            InitializeComponent so the named grids exist. Body lives in FinOpsTab.Loaders.cs. */
         InitializeFinOpsTab();
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml
index c4ddab3334..d14225223d 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml
@@ -3,6 +3,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:ui="clr-namespace:PerformanceMonitor.Ui;assembly=PerformanceMonitor.Ui"
              mc:Ignorable="d"
              d:DesignHeight="450" d:DesignWidth="900">
     <!-- Fleet-wide retained SQL Agent job-run history (issue #1433), a structural sibling of
@@ -69,14 +70,9 @@
                        Foreground="{DynamicResource ForegroundBrush}"/>
             <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="5,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
-            <ComboBox x:Name="TimeRangeComboBox" Width="100" VerticalAlignment="Center"
-                      SelectionChanged="Filter_SelectionChanged">
-                <ComboBoxItem Content="Last 24 Hours" Tag="24" IsSelected="True"/>
-                <ComboBoxItem Content="Last 7 Days" Tag="168"/>
-                <ComboBoxItem Content="Last 30 Days" Tag="720"/>
-                <ComboBoxItem Content="Last 90 Days" Tag="2160"/>
-                <ComboBoxItem Content="Last Year" Tag="8760"/>
-            </ComboBox>
+            <!-- #5562: the shared time range picker. 30 days is the "1mo" preset; 90 days and a year are typed ("90d", "365d"). -->
+            <ui:TimeRangePicker x:Name="TimeRangePickerControl" Compact="True" VerticalAlignment="Center"
+                                RangeChanged="TimeRangePicker_RangeChanged"/>
             <TextBlock Text="Server:" VerticalAlignment="Center" Margin="12,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
             <ComboBox x:Name="ServerFilterComboBox" Width="150" VerticalAlignment="Center"
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
index 83de33b89a..5a3b5fd675 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
@@ -48,6 +48,10 @@ public partial class JobHistoryTab : UserControl
     public JobHistoryTab()
     {
         InitializeComponent();
+        /* #5562: the shared picker; the old combo defaulted to the last 24 hours and offered 7, 30 and 90 days, which are
+           one click away in the picker's presets (1w, 1mo) and a typed "90d". */
+        TimeRangePickerControl.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
+        TimeRangePickerControl.Value = TimeRangePresets.Find("1d")!;
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
@@ -100,13 +104,14 @@ private async Task LoadJobsAsync()
 
         try
         {
-            var hoursBack = GetSelectedHoursBack();
+            var (windowStartUtc, windowEndUtc, windowIsLive) = ViewerTimeRangeWindow.Window(
+                TimeRangePickerControl.Value, DateTime.UtcNow, ViewerTimeHelper.CurrentDisplayZone());
             int? serverId = GetSelectedServerId();
             /* #4966: the window's start is worked out once, and the read and the data-start probe both take it. The probe starts
                beside the read; its answer is awaited only after the rows are on screen, so a probe that fails costs the note and
                never the grid. */
-            var nowUtc = DateTime.UtcNow;
-            var sinceUtc = nowUtc.AddHours(-hoursBack);
+            var nowUtc = windowEndUtc;
+            var sinceUtc = windowStartUtc;
             /* The read and the data-start probe run together: priced as two. */
             using var readFanOut = ViewerReadFanOut.Of(2);
             var dataStartTask = _dataService.GetJobHistoryDataStartAsync(serverId, sinceUtc, nowUtc);
@@ -115,6 +120,14 @@ never the grid. */
             await ViewerServerTab.AwaitReadWatchingProbeAsync(readTask, dataStartTask, "Job History");
             var all = await readTask;
             readFanOut.Release();
+            if (!windowIsLive)
+            {
+                /* #5562: the read is start-only (newest first, capped), so a range that ended in the past drops the runs after
+                   its end here. A finished range inside a busy fleet's newest 2,000 runs is exact; beyond that the cap note says
+                   the list is the newest N of everything since the start. */
+                all = all.Where(r => r.RunDateTimeUtc is not { } ran || ran < windowEndUtc).ToList();
+            }
+
             if (_loads.Superseded(nameof(LoadJobsAsync), gen)) return;
 
             /* Populate the Server / Category combos from the full (pre status/category) result, then apply
@@ -328,14 +341,6 @@ private void PopulateCategoryFilter(List<ViewerJobHistoryRow> rows)
         CategoryFilterComboBox.SelectionChanged += Filter_SelectionChanged;
     }
 
-    private int GetSelectedHoursBack()
-    {
-        if (TimeRangeComboBox.SelectedItem is ComboBoxItem item && item.Tag is string tagStr)
-        {
-            return int.TryParse(tagStr, out var hours) ? hours : 24;
-        }
-        return 24;
-    }
 
     private int? GetSelectedServerId()
     {
@@ -450,6 +455,14 @@ private void UpdateStaleDataIndicator()
 
     #region Event Handlers
 
+    private async void TimeRangePicker_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
+    {
+        if (IsLoaded)
+        {
+            await LoadJobsAsync();
+        }
+    }
+
     private async void Filter_SelectionChanged(object sender, SelectionChangedEventArgs e)
     {
         if (IsLoaded)
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/MainWindow.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/MainWindow.xaml.cs
index 9309e0768d..5accd61e7c 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/MainWindow.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/MainWindow.xaml.cs
@@ -1360,17 +1360,17 @@ private StackPanel CreateServerTabHeader(DarlingServer server)
     private void OnServerTabStatusChanged(string message) => StatusText.Text = message;
 
     /// <summary>
-    /// "Apply to All" from one server tab's toolbar: copy its selected range (and, for a custom range, the
-    /// held From/To as naive-UTC instants, which each tab draws in its own server's zone) to every OTHER open
-    /// server tab so they window on the same period. The source tab is skipped — it already holds the range.
+    /// "Apply to All" from one server tab's toolbar: copy its held range (a rolling length as it is; a fixed range
+    /// or calendar period as the naive-UTC instants it names, which each tab draws in its own server's zone) to every
+    /// OTHER open server tab so they window on the same period. The source tab is skipped — it already holds the range.
     /// </summary>
-    private void OnApplyTimeRangeToAllRequested(ViewerServerTab source, int index, DateTime? customFromUtc, DateTime? customToUtc)
+    private void OnApplyTimeRangeToAllRequested(ViewerServerTab source, PerformanceMonitor.Ui.TimeRangeSpec range)
     {
         foreach (var tab in _openServerTabs.Values)
         {
             if (tab.Content is ViewerServerTab serverTab && !ReferenceEquals(serverTab, source))
             {
-                serverTab.ApplyExternalTimeRange(index, customFromUtc, customToUtc);
+                serverTab.ApplyExternalTimeRange(range);
             }
         }
     }
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml b/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml
index 1fb1e813f6..113610e8ff 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml
@@ -179,14 +179,10 @@
                 <StackPanel Orientation="Horizontal" Margin="0,8,0,0">
                     <TextBlock Text="Default time range:" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,8,0"/>
-                    <ComboBox x:Name="DefaultTimeRangeCombo" Width="140" VerticalAlignment="Center"
-                              ToolTip="Time window each newly-opened server tab starts on">
-                        <ComboBoxItem Content="Last 1 hour"/>
-                        <ComboBoxItem Content="Last 4 hours"/>
-                        <ComboBoxItem Content="Last 12 hours"/>
-                        <ComboBoxItem Content="Last 24 hours"/>
-                        <ComboBoxItem Content="Last 7 days"/>
-                    </ComboBox>
+                    <!-- #5562: the shared picker. A fixed range is not kept as a default (it names concrete dates). -->
+                    <ui:TimeRangePicker x:Name="DefaultTimeRangeCombo" VerticalAlignment="Center"
+                                        ToolTip="Time window each newly-opened server tab starts on"
+                                        RangeChanged="DefaultTimeRange_RangeChanged"/>
                 </StackPanel>
                 <!-- Folded in from #1401: the auto-refresh defaults for newly-opened server tabs. -->
                 <CheckBox x:Name="AutoRefreshCheckBox" Content="Auto-refresh newly-opened server tabs"
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml.cs
index e438776bec..89babc8c7d 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/SettingsWindow.xaml.cs
@@ -274,19 +274,40 @@ private void LoadViewerPreferences(ViewerPreferences preferences)
         var normalized = new ViewerPreferences
         {
             DefaultTimeRangeIndex = preferences.DefaultTimeRangeIndex,
+            DefaultTimeRange = preferences.DefaultTimeRange,
             AutoRefreshEnabled = preferences.AutoRefreshEnabled,
             AutoRefreshIntervalIndex = preferences.AutoRefreshIntervalIndex,
         }.Normalize();
 
-        DefaultTimeRangeCombo.SelectedIndex = normalized.DefaultTimeRangeIndex;
+        DefaultTimeRangeCombo.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
+        DefaultTimeRangeCombo.Value = ViewerTimeRangeWindow.DefaultFor(normalized);
+        _lastPersistableDefaultRange = DefaultTimeRangeCombo.Value;
         AutoRefreshCheckBox.IsChecked = normalized.AutoRefreshEnabled;
         AutoRefreshIntervalCombo.SelectedIndex = normalized.AutoRefreshIntervalIndex;
         AutoRefreshIntervalCombo.IsEnabled = normalized.AutoRefreshEnabled;
     }
 
+    /// <summary>A fixed or since range cannot be a standing default (#5562): it stays on the picker's last rolling or period
+    /// pick, so Save never writes concrete dates.</summary>
+    private void DefaultTimeRange_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
+    {
+        if (ViewerTimeRangeWindow.IsPersistable(e.Spec))
+        {
+            _lastPersistableDefaultRange = e.Spec;
+        }
+        else
+        {
+            DefaultTimeRangeCombo.Value = _lastPersistableDefaultRange;
+        }
+    }
+
+    private TimeRangeSpec _lastPersistableDefaultRange = TimeRangePresets.Find("1d")!;
+
     private ViewerPreferences BuildViewerPreferences() => new ViewerPreferences
     {
-        DefaultTimeRangeIndex = DefaultTimeRangeCombo.SelectedIndex,
+        DefaultTimeRange = ViewerTimeRangeWindow.IsPersistable(DefaultTimeRangeCombo.Value)
+            ? DefaultTimeRangeCombo.Value.Id
+            : _lastPersistableDefaultRange.Id,
         AutoRefreshEnabled = AutoRefreshCheckBox.IsChecked == true,
         AutoRefreshIntervalIndex = AutoRefreshIntervalCombo.SelectedIndex,
     }.Normalize();
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.AlertHistory.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.AlertHistory.cs
index b0696829bd..ec6871cfc9 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.AlertHistory.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.AlertHistory.cs
@@ -165,27 +165,52 @@ public sealed partial class ViewerDataService
     a.context_json,
     a.server_name AS stored_server_name";
 
-    /// <summary>Per-server read. $1 window start, $2 server_id, $3 limit (naive UTC / int / int).</summary>
+    /// <summary>Per-server read. $1 window start, $2 server_id, $3 limit, $4 window end, exclusive (naive UTC / int / int / naive UTC).
+    /// The end (#5562) is what a finished calendar period or a typed range needs; a live window passes a far-future instant.</summary>
     public const string AlertHistorySql = @"
 SELECT" + AlertHistorySelectColumns + @"
 FROM config_alert_log a
 LEFT JOIN servers s ON s.server_id = a.server_id
 WHERE a.alert_time >= $1
 AND   a.server_id = $2
+AND   a.alert_time < $4
 AND   a.dismissed = FALSE
 ORDER BY a.alert_time DESC
 LIMIT $3";
 
-    /// <summary>All-servers read (the Alert History default). $1 window start, $2 limit (naive UTC / int).</summary>
+    /// <summary>All-servers read (the Alert History default). $1 window start, $2 limit, $3 window end, exclusive (naive UTC / int / naive UTC).</summary>
     public const string AlertHistoryAllServersSql = @"
 SELECT" + AlertHistorySelectColumns + @"
 FROM config_alert_log a
 LEFT JOIN servers s ON s.server_id = a.server_id
 WHERE a.alert_time >= $1
+AND   a.alert_time < $3
 AND   a.dismissed = FALSE
 ORDER BY a.alert_time DESC
 LIMIT $2";
 
+    /// <summary>The "no end" instant a live window passes: far past any alert, inside the timestamp type's range.</summary>
+    internal static readonly DateTime AlertWindowOpenEnd = new(9999, 12, 31, 0, 0, 0, DateTimeKind.Unspecified);
+
+    /// <summary>Window dismiss with an end (#5562), per server: $1 window start, $2 server_id, $3 window end (exclusive).
+    /// The shared dismiss-all statement has no end, which is right for a window that runs to now; a finished period must
+    /// dismiss only the rows it shows.</summary>
+    internal const string DismissWindowForServerSql = @"
+UPDATE config_alert_log
+SET    dismissed = TRUE
+WHERE  alert_time >= $1
+AND    server_id = $2
+AND    alert_time < $3
+AND    dismissed = FALSE";
+
+    /// <summary>Window dismiss with an end (#5562), every server: $1 window start, $2 window end (exclusive).</summary>
+    internal const string DismissWindowAllServersSql = @"
+UPDATE config_alert_log
+SET    dismissed = TRUE
+WHERE  alert_time >= $1
+AND    alert_time < $2
+AND    dismissed = FALSE";
+
     /// <summary>How long the alert-history reads serve the fleet's server clocks before reading them again
     /// (#4766). The shell polls the history on every refresh tick (30s by default, 10s at the fastest), and a
     /// server's clock only changes with a new <c>server_properties</c> row, which lands when the server connects
@@ -198,8 +223,14 @@ ORDER BY a.alert_time DESC
     /// <paramref name="serverId"/> it aggregates ALL servers (the tab's default); with one it scopes to
     /// that server (the Server filter combo). Mirrors Lite's optional-serverId GetAlertHistoryAsync.
     /// </summary>
-    public async Task<List<ViewerAlertRow>> GetAlertHistoryAsync(
+    public Task<List<ViewerAlertRow>> GetAlertHistoryAsync(
         DateTime sinceUtc, int? serverId = null, int limit = 500, CancellationToken cancellationToken = default)
+        => GetAlertHistoryWindowAsync(sinceUtc, null, serverId, limit, cancellationToken);
+
+    /// <summary><see cref="GetAlertHistoryAsync"/> over a window that may END before now (#5562): <paramref name="untilUtc"/> is
+    /// exclusive, and null means the window runs to now.</summary>
+    public async Task<List<ViewerAlertRow>> GetAlertHistoryWindowAsync(
+        DateTime sinceUtc, DateTime? untilUtc, int? serverId = null, int limit = 500, CancellationToken cancellationToken = default)
     {
         var rows = new List<ViewerAlertRow>();
 
@@ -222,6 +253,10 @@ same answer each time. A server filter reads the same fleet snapshot and looks i
             command.Parameters.Add(new NpgsqlParameter<int> { TypedValue = serverId.Value });
         }
         command.Parameters.Add(new NpgsqlParameter<int> { TypedValue = limit });
+        command.Parameters.Add(new NpgsqlParameter<DateTime>
+        {
+            TypedValue = DateTime.SpecifyKind(untilUtc ?? AlertWindowOpenEnd, DateTimeKind.Unspecified),
+        });
 
         await using var reader = await command.ExecuteReaderAsync(cancellationToken);
         while (await reader.ReadAsync(cancellationToken))
@@ -299,9 +334,30 @@ public async Task<int> DismissAlertsAsync(IReadOnlyList<ViewerAlertRow> alerts,
     /// <paramref name="serverId"/> is set, otherwise across all servers (matching the current filter).
     /// Returns the number of rows changed.
     /// </summary>
-    public async Task<int> DismissAllVisibleAlertsAsync(
+    public Task<int> DismissAllVisibleAlertsAsync(
         DateTime sinceUtc, int? serverId = null, CancellationToken cancellationToken = default)
+        => DismissAllVisibleAlertsWindowAsync(sinceUtc, null, serverId, cancellationToken);
+
+    /// <summary><see cref="DismissAllVisibleAlertsAsync"/> over a window that may END before now (#5562): only the rows the
+    /// grid shows for that window. <paramref name="untilUtc"/> is exclusive; null means the window runs to now.</summary>
+    public async Task<int> DismissAllVisibleAlertsWindowAsync(
+        DateTime sinceUtc, DateTime? untilUtc, int? serverId = null, CancellationToken cancellationToken = default)
     {
+        if (untilUtc is { } until)
+        {
+            /* #5562: a window that ended in the past dismisses only the rows it shows. */
+            await using var bounded = _dataSource.CreateCommand(serverId.HasValue ? DismissWindowForServerSql : DismissWindowAllServersSql);
+            bounded.CommandTimeout = ViewerCommandDeadlines.CurrentInteractiveReadSeconds;
+            bounded.Parameters.Add(new NpgsqlParameter<DateTime> { TypedValue = DateTime.SpecifyKind(sinceUtc, DateTimeKind.Unspecified) });
+            if (serverId.HasValue)
+            {
+                bounded.Parameters.Add(new NpgsqlParameter<int> { TypedValue = serverId.Value });
+            }
+
+            bounded.Parameters.Add(new NpgsqlParameter<DateTime> { TypedValue = DateTime.SpecifyKind(until, DateTimeKind.Unspecified) });
+            return await ExecuteWriteAsync(bounded, cancellationToken);
+        }
+
         await using var command = AlertDismissStore.CreateDismissAllCommand(
             _dataSource, sinceUtc, serverId, ViewerCommandDeadlines.CurrentInteractiveReadSeconds);
 
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerPreferences.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerPreferences.cs
index 0e43b46773..c0b1ed954a 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerPreferences.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerPreferences.cs
@@ -42,9 +42,17 @@ covers the five presets (0..4) — "Custom Range" needs concrete From/To dates t
     internal const int MaxTimeRangeIndex = 4;
     internal const int MaxAutoRefreshIntervalIndex = 2;
 
-    /// <summary>Default time window for a newly-opened server tab: 0=1h, 1=4h, 2=12h, 3=24h, 4=7d.</summary>
+    /// <summary>LEGACY default time window for a newly-opened server tab: 0=1h, 1=4h, 2=12h, 3=24h, 4=7d. Kept so a file
+    /// written before the shared time range picker (#5562) still opens on the same range, and so a file written now
+    /// still opens on an older build (the nearest of the five). <see cref="DefaultTimeRange"/> wins when it holds a range.</summary>
     public int DefaultTimeRangeIndex { get; set; } = DefaultTimeRangeIndexValue;
 
+    /// <summary>The default time window as the picker names it (#5562): a rolling length ("4h", "1w", "1mo") or a calendar
+    /// period ("today", "previous-week"). Null or unrecognised means the legacy <see cref="DefaultTimeRangeIndex"/> decides.
+    /// A fixed or since range is never kept here: like Custom, it names concrete instants that make no sense as a standing
+    /// default.</summary>
+    public string? DefaultTimeRange { get; set; }
+
     /// <summary>Whether a newly-opened server tab starts with auto-refresh running.</summary>
     public bool AutoRefreshEnabled { get; set; } = true;
 
@@ -70,6 +78,12 @@ internal ViewerPreferences Normalize()
             DefaultTimeRangeIndex = DefaultTimeRangeIndexValue;
         }
 
+        /* #5562: the string id wins when it names a range a default can be; otherwise it is rebuilt from the legacy index
+           (an old file, or a hand edit to something unknown), so the two always agree on what a new tab opens on. */
+        var chosen = ViewerTimeRangeWindow.DefaultFor(this);
+        DefaultTimeRange = chosen.Id;
+        DefaultTimeRangeIndex = ViewerTimeRangeWindow.ToLegacyIndex(chosen);
+
         if (AutoRefreshIntervalIndex < 0 || AutoRefreshIntervalIndex > MaxAutoRefreshIntervalIndex)
         {
             AutoRefreshIntervalIndex = DefaultAutoRefreshIntervalIndexValue;
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs
index 75fa630c62..ae475ff8a2 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs
@@ -96,7 +96,7 @@ read. Honor a pending deep-link window instead so a concurrent activation load u
         var (totalCount, snapshots) = dataReadTask.Result;
         _querySnapshotsFilterMgr!.UpdateData(snapshots);
         LatestSnapshotIndicator.Text = snapshots.Count < totalCount ? $"Showing the newest 1,000 of {totalCount:N0}" : "";
-        UpdateTruncationBanner(QuerySnapshotsTruncationBanner, await DataStartOrNullAsync(dataStartTask, "Active Queries"), startUtc);
+        UpdateTruncationBanner(QuerySnapshotsTruncationBanner, await PrimaryDataStartAsync(dataStartTask, "Active Queries"), startUtc);
         await LoadActiveQueriesSlicerAsync(startUtc, endUtc);
     }
 
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs
index ea4f05211a..11c609dbb4 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs
@@ -234,7 +234,7 @@ covers them. */
                 var blocked = await blockedTask;
                 RenderCurrentWaitsDurationChart(duration);
                 RenderCurrentWaitsBlockedChart(blocked);
-                UpdateTruncationBanner(CurrentWaitsTruncationBanner, await DataStartOrNullAsync(dataStartTask, "Current Waits"), startUtc);
+                UpdateTruncationBanner(CurrentWaitsTruncationBanner, await PrimaryDataStartAsync(dataStartTask, "Current Waits"), startUtc);
                 break;
             }
             case BlockedProcessReportsSubTabIndex:
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs
index c7395a345c..50e63ad0c5 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs
@@ -191,7 +191,7 @@ private async Task LoadPgCpuUtilizationAsync(DateTime startUtc, DateTime endUtc)
         readFanOut.Release();
 
         PgCpuGrid.ItemsSource = rows;
-        UpdateTruncationBanner(PgCpuDataStartBanner, await DataStartOrNullAsync(dataStartTask, "PostgreSQL CPU"), startUtc);
+        UpdateTruncationBanner(PgCpuDataStartBanner, await PrimaryDataStartAsync(dataStartTask, "PostgreSQL CPU"), startUtc);
         PgCpuNote.Text = PanelNote("pg_cpu_utilization", rows.Count,
             "This collector samples AWS Performance Insights on a 5-minute cadence, so a server added "
             + "recently may have nothing here yet.");
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs
index 849d32fa35..0c8866dc6d 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs
@@ -186,7 +186,7 @@ private async Task LoadTopQueriesAsync(DateTime startUtc, DateTime endUtc)
            ViewerDataService.GetTopQueriesByCpuTierAsync) — the raw-floor banner (#4231 stage 1/2) and this
            tier disclosure are independent facts, so both may show at once (a window aged past raw AND
            routed to hourly). */
-        UpdateTruncationBanner(QueryStatsTruncationBanner, await DataStartOrNullAsync(floorTask, "Query Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
+        UpdateTruncationBanner(QueryStatsTruncationBanner, await PrimaryDataStartAsync(floorTask, "Query Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
         await LoadQueryStatsSlicerAsync(startUtc, endUtc);
         await RefreshQueryStatsComparisonAsync(startUtc, endUtc);
     }
@@ -238,7 +238,7 @@ private async Task LoadTopProceduresAsync(DateTime startUtc, DateTime endUtc)
         SetDefaultSortIfNone(ProcedureStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
         /* #4231 stage 3b: an hourly-routed page holds no object_type/sql_handle/plan_handle — the raw-floor
            banner and this tier disclosure are independent facts, same reasoning as the Queries sub-tab. */
-        UpdateTruncationBanner(ProcStatsTruncationBanner, await DataStartOrNullAsync(floorTask, "Procedure Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
+        UpdateTruncationBanner(ProcStatsTruncationBanner, await PrimaryDataStartAsync(floorTask, "Procedure Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
         await LoadProcStatsSlicerAsync(startUtc, endUtc);
         await RefreshProcStatsComparisonAsync(startUtc, endUtc);
     }
@@ -255,7 +255,7 @@ ordinary read (M1) — null tells the gate this end is open. */
         var (rows, widePlan) = dataReadTask.Result;
         _queryStoreFilterMgr!.UpdateData(rows);
         SetDefaultSortIfNone(QueryStoreGrid, "TotalDurationMs", ListSortDirection.Descending);
-        UpdateTruncationBanner(QueryStoreTruncationBanner, await DataStartOrNullAsync(floorTask, "Query Store"), startUtc, widePlan: widePlan);
+        UpdateTruncationBanner(QueryStoreTruncationBanner, await PrimaryDataStartAsync(floorTask, "Query Store"), startUtc, widePlan: widePlan);
         await LoadQueryStoreSlicerAsync(startUtc, endUtc);
         await RefreshQueryStoreComparisonAsync(startUtc, endUtc);
     }
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
index f21f92391c..cce987b79a 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
@@ -11,8 +11,6 @@
 using System.Threading.Tasks;
 using System.Windows;
 using System.Windows.Controls;
-using System.Windows.Controls.Primitives;
-using System.Windows.Media;
 using System.Windows.Threading;
 using PerformanceMonitor.Analysis.Baselines;
 using PerformanceMonitor.Ui;
@@ -21,34 +19,31 @@ namespace PerformanceMonitor.Darling.Viewer;
 
 /// <summary>
 /// The per-server toolbar's time-window + auto-refresh + time-display state (the header row added above
-/// the inner tab strip), mirroring Lite's <c>ServerTab.TimeRange.cs</c>: a custom range is held as two
-/// naive-UTC instants (<see cref="CustomRangeState"/>, #4766) and the From/To pickers are a drawing of them in
-/// the CURRENT display mode's zone (Server/Local/UTC — <see cref="ViewerTimeHelper.DisplayZoneFor"/>, on this
-/// tab's own server clock, ported from Lite's <c>TimeDisplayModeBox</c>). Only a typed edit reads text back,
-/// through <see cref="CustomRangeState.ApplyEdit"/>, so a range that crosses a daylight saving change keeps the
-/// instants it names and a display-mode switch changes only the text. This replaces the old hardcoded
-/// 24-hour <c>s_dataWindow</c>: every inner-tab load reads <see cref="GetWindowUtc"/> (preset
-/// 1h/4h/12h/24h/7d or a custom From/To), the auto-refresh cadence comes from the toolbar instead of
-/// MainWindow's fleet-refresh timer, and the display-mode picker re-renders the visible tab so every
-/// timestamp honors the chosen mode.
+/// the inner tab strip), mirroring Lite's <c>ServerTab.TimeRange.cs</c>. The window is the shared
+/// <see cref="TimeRangePicker"/> (#5562): rolling presets from 5 minutes, calendar periods, or a typed or
+/// calendar-picked range, held as a <see cref="TimeRangeSpec"/> that the picker draws in this tab's display zone
+/// (Server/Local/UTC, <see cref="ViewerTimeHelper.DisplayZoneFor"/> on this tab's own server clock). A fixed range
+/// holds its two naive-UTC instants, so a display-mode switch only redraws the text (#4766) and a range that
+/// crosses a daylight saving change keeps the instants it names. Every inner-tab load reads <see cref="GetWindowUtc"/>
+/// (<see cref="ViewerTimeRangeWindow"/> does the arithmetic), the auto-refresh cadence comes from the toolbar instead
+/// of MainWindow's fleet-refresh timer, and the display-mode picker re-renders the visible tab so every timestamp
+/// honors the chosen mode. There is no reach limit on the desktop (#5562): a long period reads what the data holds,
+/// through the retention routers the long-window reads already use.
 /// </summary>
 public partial class ViewerServerTab
 {
-    /// <summary>The "Custom Range" slot in <c>TimeRangeCombo</c> (after 1h/4h/12h/24h/7d).</summary>
-    private const int CustomRangeIndex = 5;
-
-    /// <summary>Guards the range handlers while pickers/combo are set programmatically (Apply-to-all,
-    /// custom-range defaults) so one external change drives exactly one reload, not a cascade.</summary>
+    /// <summary>Guards the range handlers while the picker or the display-mode box is set programmatically (Apply-to-all,
+    /// the day drill, the default seed) so one external change drives exactly one reload, not a cascade.</summary>
     private bool _suppressRangeEvents;
 
     private DispatcherTimer? _autoRefreshTimer;
 
     /// <summary>
-    /// Raised when the user clicks "Apply to All": MainWindow broadcasts the selected range (index plus,
-    /// for a custom range, the held From/To as naive-UTC instants) to every other open server
-    /// tab. The source tab is carried so the broadcast can skip it (it already holds the range).
+    /// Raised when the user clicks "Apply to All": MainWindow broadcasts the held range to every other open server
+    /// tab (<see cref="ViewerTimeRangeWindow.ForBroadcast"/>: a calendar period goes as the instants it names). The
+    /// source tab is carried so the broadcast can skip it (it already holds the range).
     /// </summary>
-    public event Action<ViewerServerTab, int, DateTime?, DateTime?>? ApplyTimeRangeRequested;
+    public event Action<ViewerServerTab, TimeRangeSpec>? ApplyTimeRangeRequested;
 
     /// <summary>
     /// Raised when the user changes the toolbar's Server/Local/UTC display picker. MainWindow persists the
@@ -66,48 +61,36 @@ public partial class ViewerServerTab
     private ServerClock _serverClock =
         ServerClock.FixedOffset((int)TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow).TotalMinutes);
 
-    /// <summary>The custom range this tab holds (#4766): two naive-UTC instants, or nothing while a preset is
-    /// selected. The From/To pickers are drawn from it (<see cref="RenderCustomRange"/>); a picker edit changes
-    /// one side of it (<see cref="ApplyPickerEdit"/>) and nothing else reads the pickers' text back.</summary>
-    private readonly CustomRangeState _customRange = new();
-
-    /// <summary>The zone the pickers are drawn in and a typed value is read in: the current display mode's, on
-    /// THIS tab's own server clock rather than the process-wide one another tab may have set last.</summary>
+    /// <summary>The zone the picker draws and reads typed times in: the current display mode's, on THIS tab's own
+    /// server clock rather than the process-wide one another tab may have set last.</summary>
     private TimeZoneInfo TabDisplayZone => ViewerTimeHelper.DisplayZoneFor(ViewerTimeHelper.CurrentDisplayMode, _serverClock);
 
-    /// <summary>Preset combo index → hours back. Index 5 (custom) and any stray value fall to the
-    /// viewer's historical 24-hour default. Pure + static so the mapping is unit-testable.</summary>
-    internal static int TimeRangeIndexToHours(int index) => index switch
+    /// <summary>The range the toolbar holds (rolling, calendar period, fixed or since).</summary>
+    internal TimeRangeSpec HeldRange => RangePicker.Value;
+
+    /// <summary>Preset combo index → hours back, the legacy mapping the preferences file still uses
+    /// (<see cref="ViewerTimeRangeWindow.LegacyIndexToHours"/>). Index 5 (the old Custom slot) and any stray value fall to
+    /// the viewer's historical 24-hour default. Pure + static so the mapping is unit-testable.</summary>
+    internal static int TimeRangeIndexToHours(int index) => ViewerTimeRangeWindow.LegacyIndexToHours(index);
+
+    /// <summary>Wires the picker to this tab: its display zone and the range it starts on (the persisted default).
+    /// Called from the constructor after <c>InitializeComponent</c>.</summary>
+    private void InitializeRangePicker(ViewerPreferences preferences)
     {
-        0 => 1,
-        1 => 4,
-        2 => 12,
-        3 => 24,
-        4 => 168,
-        _ => 24,
-    };
+        RangePicker.ZoneProvider = () => TabDisplayZone;
+        RangePicker.Value = ViewerTimeRangeWindow.DefaultFor(preferences);
+    }
 
-    /// <summary>Populates the custom-range hour (00:00–23:00) and minute (:00/:15/:30/:45) combos,
-    /// matching Lite's <c>InitializeTimeComboBoxes</c>. Called from the constructor after
-    /// <c>InitializeComponent</c>.</summary>
-    private void InitializeTimeComboBoxes()
+    /// <summary>The picker raised a pick (preset, period, typed text or calendar): reload the active inner tab, which
+    /// reads the new window through <see cref="GetWindowUtc"/>.</summary>
+    private async void RangePicker_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
-        var hours = new List<string>();
-        for (int h = 0; h < 24; h++)
+        if (!IsLoaded || _suppressRangeEvents)
         {
-            hours.Add(DateTime.Today.AddHours(h).ToString("HH:00"));
+            return;
         }
 
-        FromHourCombo.ItemsSource = hours;
-        ToHourCombo.ItemsSource = hours;
-        FromHourCombo.SelectedIndex = 0;   // 00:00
-        ToHourCombo.SelectedIndex = 23;    // 23:00
-
-        var minutes = new List<string> { ":00", ":15", ":30", ":45" };
-        FromMinuteCombo.ItemsSource = minutes;
-        ToMinuteCombo.ItemsSource = minutes;
-        FromMinuteCombo.SelectedIndex = 0; // :00
-        ToMinuteCombo.SelectedIndex = 3;   // :45
+        await RefreshActiveInnerTabAsync();
     }
 
     /// <summary>Wires the auto-refresh timer (default 1 minute, matching the old fixed 60-second cadence)
@@ -135,247 +118,120 @@ private async void OnAutoRefreshTick(object? sender, EventArgs e)
         await RefreshActiveInnerTabAsync();
     }
 
-    // ── Window computation ───────────────────────────────────────────────────────────
 
-    /// <summary>True when the user picked "Custom Range", a range is held, AND both date pickers hold a value.</summary>
-    private bool IsCustomRange => TimeRangeCombo.SelectedIndex == CustomRangeIndex
-        && _customRange.IsCustom
-        && FromDatePicker?.SelectedDate != null
-        && ToDatePicker?.SelectedDate != null;
+    // ── Window computation ───────────────────────────────────────────────────────────
 
     /// <summary>
     /// The current window as store-native naive-UTC bounds, driving every inner-tab load (it replaces the
-    /// old fixed 24-hour <c>s_dataWindow</c>). A preset ends "now"; a valid custom range uses its From/To.
+    /// old fixed 24-hour <c>s_dataWindow</c>). A live range ends "now" and slides on every call; a fixed range or a
+    /// finished calendar period keeps its instants. A sub-hour span (5, 15, 30 minutes) flows through unchanged: the
+    /// reads take two instants and size their buckets in minutes.
     /// </summary>
     private (DateTime startUtc, DateTime endUtc) GetWindowUtc()
     {
-        if (IsCustomRange)
-        {
-            var (fromUtc, toUtc) = GetCustomRangeUtc();
-            if (fromUtc.HasValue && toUtc.HasValue)
-            {
-                return (fromUtc.Value, toUtc.Value);
-            }
-        }
-
-        var endUtc = DateTime.UtcNow;
-        return (endUtc.AddHours(-TimeRangeIndexToHours(TimeRangeCombo.SelectedIndex)), endUtc);
+        var (startUtc, endUtc, _) = ViewerTimeRangeWindow.Window(RangePicker.Value, DateTime.UtcNow, TabDisplayZone);
+        return (startUtc, endUtc);
     }
 
-    /// <summary>Hours-back for the reads that take an integer window (the Overview lanes + Collection
-    /// Health log). A custom range collapses to its rounded-up span so those surfaces still track it.</summary>
+    /// <summary>True when the window ends in the past (a fixed range, or a calendar period that has finished), so a read
+    /// that is start-only server-side must bound its end itself (the CPU chart). A window that slides with now is not.</summary>
+    private bool IsCustomRange => !ViewerTimeRangeWindow.Window(RangePicker.Value, DateTime.UtcNow, TabDisplayZone).IsLive;
+
+    /// <summary>Hours-back for the reads that take an integer window: the window's span rounded up to whole hours, at
+    /// least one (<see cref="ViewerTimeRangeWindow.HoursBack"/>).</summary>
     private int GetWindowHoursBack()
     {
-        if (IsCustomRange)
-        {
-            var (fromUtc, toUtc) = GetCustomRangeUtc();
-            if (fromUtc.HasValue && toUtc.HasValue)
-            {
-                var hours = (int)Math.Ceiling((toUtc.Value - fromUtc.Value).TotalHours);
-                return hours < 1 ? 1 : hours;
-            }
-        }
-
-        return TimeRangeIndexToHours(TimeRangeCombo.SelectedIndex);
+        var (startUtc, endUtc) = GetWindowUtc();
+        return ViewerTimeRangeWindow.HoursBack(startUtc, endUtc);
     }
 
-    /// <summary>Custom From/To as naive-UTC bounds for the Overview lanes (null,null when not a valid
-    /// custom range — the lanes then fall back to their hours-back window).</summary>
+    /// <summary>The window's two bounds for the Overview lanes, ALWAYS as the explicit pair: the lanes then plot exactly the
+    /// window (a 15-minute or a calendar-period window is not rounded to whole hours back from now).</summary>
     private (DateTime? fromUtc, DateTime? toUtc) GetOverviewCustomRange()
-        => IsCustomRange ? GetCustomRangeUtc() : (null, null);
-
-    /// <summary>The held custom range as naive-UTC bounds, or (null,null) while a preset is selected. The pickers
-    /// are not parsed here: they are a drawing of these two instants, and a typed edit already changed the held
-    /// side (<see cref="ApplyPickerEdit"/>), so a window that crosses a daylight saving change keeps the instants
-    /// it names (#4766).</summary>
-    private (DateTime? fromUtc, DateTime? toUtc) GetCustomRangeUtc()
-        => _customRange.IsCustom ? (_customRange.FromUtc, _customRange.ToUtc) : (null, null);
-
-    /// <summary>Draws the held range on the From/To pickers as the wall clock of <paramref name="zone"/> (the hour
-    /// and 15-minute combos as always). Nothing is drawn while a preset is selected. Runs under
-    /// <see cref="_suppressRangeEvents"/> so the drawing is not read back as an edit, and leaves the flag as the
-    /// caller had it.</summary>
-    private void RenderCustomRange(TimeZoneInfo zone)
     {
-        if (FromDatePicker is null || _customRange.Render(zone) is not { } wall)
-        {
-            return;
-        }
-
-        var wasSuppressed = _suppressRangeEvents;
-        _suppressRangeEvents = true;
-        try
-        {
-            FromDatePicker.SelectedDate = wall.From.Date;
-            FromHourCombo.SelectedIndex = wall.From.Hour;
-            FromMinuteCombo.SelectedIndex = wall.From.Minute / 15;
-            ToDatePicker.SelectedDate = wall.To.Date;
-            ToHourCombo.SelectedIndex = wall.To.Hour;
-            ToMinuteCombo.SelectedIndex = wall.To.Minute / 15;
-        }
-        finally
-        {
-            _suppressRangeEvents = wasSuppressed;
-        }
+        var (startUtc, endUtc) = GetWindowUtc();
+        return (startUtc, endUtc);
     }
 
-    /// <summary>Holds what the two pickers currently read as the custom range: each typed value is a wall clock in
-    /// <paramref name="zone"/>, and FROM takes the earliest instant that reads at or after it and TO the latest at
-    /// or before it (<see cref="DisplayZone.ToUtcBound"/>). Returns false, holding nothing, when a date is unset.</summary>
-    private bool HoldPickersAsRange(TimeZoneInfo zone)
-    {
-        var from = GetDateTimeFromPickers(FromDatePicker!, FromHourCombo, FromMinuteCombo);
-        var to = GetDateTimeFromPickers(ToDatePicker!, ToHourCombo, ToMinuteCombo);
-        if (!from.HasValue || !to.HasValue)
-        {
-            return false;
-        }
+    private static readonly TimeSpan ScheduleOverridesMaxAge = TimeSpan.FromMinutes(5);
 
-        _customRange.Set(
-            DisplayZone.ToUtcBound(from.Value, zone, BoundSide.From),
-            DisplayZone.ToUtcBound(to.Value, zone, BoundSide.To));
-        return true;
-    }
+    private IReadOnlyList<CollectorScheduleRow>? _scheduleOverrides;
 
-    /// <summary>A user edit of one picker (its date, hour or minute): reads that side's typed wall clock back as an
-    /// instant in this tab's zone (<see cref="CustomRangeState.ApplyEdit"/>) and draws both pickers from the held
-    /// range again, so a time that never happened shows the change instant and the other side is untouched. With no
-    /// range held yet, both pickers are held together.</summary>
-    private void ApplyPickerEdit(object? sender)
-    {
-        var zone = TabDisplayZone;
-        var fromSide = ReferenceEquals(sender, FromDatePicker)
-            || ReferenceEquals(sender, FromHourCombo)
-            || ReferenceEquals(sender, FromMinuteCombo);
-        var side = fromSide ? BoundSide.From : BoundSide.To;
-        var wall = fromSide
-            ? GetDateTimeFromPickers(FromDatePicker!, FromHourCombo, FromMinuteCombo)
-            : GetDateTimeFromPickers(ToDatePicker!, ToHourCombo, ToMinuteCombo);
-
-        if (_customRange.IsCustom && wall.HasValue)
-        {
-            _customRange.ApplyEdit(wall.Value, side, zone);
-        }
-        else if (!HoldPickersAsRange(zone))
-        {
-            return;
-        }
-
-        RenderCustomRange(zone);
-    }
-
-    private static DateTime? GetDateTimeFromPickers(DatePicker datePicker, ComboBox hourCombo, ComboBox minuteCombo)
-    {
-        if (datePicker?.SelectedDate is not { } date)
-        {
-            return null;
-        }
+    private string? _noteCollector;
 
-        int hour = hourCombo.SelectedIndex >= 0 ? hourCombo.SelectedIndex : 0;
-        int minute = minuteCombo.SelectedIndex >= 0 ? minuteCombo.SelectedIndex * 15 : 0;
-        return date.Date.AddHours(hour).AddMinutes(minute);
-    }
+    private DateTime _scheduleOverridesReadUtc;
 
-    // ── Toolbar handlers ─────────────────────────────────────────────────────────────
+    /// <summary>Redraws the picker's resolved text from the clock, the zone and the notes. Run when the display zone moved
+    /// and on every refresh, so a range that slides with now shows the window it is reading.</summary>
+    private void RefreshRangePicker() => RangePicker.Refresh();
 
-    private async void TimeRangeCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    /// <summary>
+    /// Sets the picker's "collected every N minutes" note (#5562 R3) from the main collector of the inner tab on screen and
+    /// that collector's ACTUAL interval on this server (the schedule overrides, else the shipped default). A read that
+    /// fails leaves the shipped default; a tab with no main collector shows no note.
+    /// </summary>
+    private async Task UpdateSampleIntervalAsync()
     {
-        if (!IsLoaded || _suppressRangeEvents)
+        try
         {
-            return;
-        }
-
-        var isCustom = TimeRangeCombo.SelectedIndex == CustomRangeIndex;
-        var visibility = isCustom ? Visibility.Visible : Visibility.Collapsed;
+            var collector = ViewerTimeRangeWindow.MainCollectorFor((InnerTabs?.SelectedItem as TabItem)?.Header as string);
+            if (!string.Equals(collector, _noteCollector, StringComparison.Ordinal))
+            {
+                /* A different top-level tab: the data-start note belonged to the last tab's surface, so it clears here and
+                   the new tab's own probe sets it again. */
+                _noteCollector = collector;
+                RecordDataStart(null);
+            }
 
-        if (FromDatePicker != null)
-        {
-            FromDatePicker.Visibility = visibility;
-            FromHourCombo.Visibility = visibility;
-            FromMinuteCombo.Visibility = visibility;
-            ToLabel.Visibility = visibility;
-            ToDatePicker.Visibility = visibility;
-            ToHourCombo.Visibility = visibility;
-            ToMinuteCombo.Visibility = visibility;
-
-            if (isCustom)
+            IReadOnlyList<CollectorScheduleRow>? overrides = null;
+            if (collector is not null)
             {
-                /* Hold what the pickers read as the range, in this tab's zone (#4766). With no date yet, seed a
-                   sensible default first so switching to Custom shows a real window; the picker changes below
-                   drive the reload. Suppress so the picker writes coalesce into one load. */
-                _suppressRangeEvents = true;
                 try
                 {
-                    if (FromDatePicker.SelectedDate == null)
+                    /* The schedule table is small but the refresh runs every 30 seconds to 5 minutes per tab, so the rows are
+                       read at most every five minutes. */
+                    if (_scheduleOverrides is null || DateTime.UtcNow - _scheduleOverridesReadUtc > ScheduleOverridesMaxAge)
                     {
-                        FromDatePicker.SelectedDate = DateTime.Today.AddDays(-1);
-                        ToDatePicker.SelectedDate = DateTime.Today;
+                        _scheduleOverrides = await _dataService.GetCollectorSchedulesAsync();
+                        _scheduleOverridesReadUtc = DateTime.UtcNow;
                     }
 
-                    var zone = TabDisplayZone;
-                    if (HoldPickersAsRange(zone))
-                    {
-                        RenderCustomRange(zone);
-                    }
+                    overrides = _scheduleOverrides;
                 }
-                finally
+                catch (Exception ex)
                 {
-                    _suppressRangeEvents = false;
+                    ViewerLogger.Warn("ViewerServerTab", $"time range note: could not read the collector schedule, using the shipped cadence | {ex.GetType().Name}: {ex.Message}");
                 }
             }
 
-            if (!isCustom)
-            {
-                /* #2154: a DatePicker's calendar dropdown is a POPUP, which lives outside the visual
-                   tree's visibility — collapsing the picker does not close an already-open dropdown,
-                   so backing out of Custom Range without picking a date left an orphaned floating
-                   calendar on screen. Close them explicitly alongside the collapse (Lite twin fix). */
-                FromDatePicker.IsDropDownOpen = false;
-                ToDatePicker.IsDropDownOpen = false;
-            }
-        }
-
-        if (!isCustom)
-        {
-            /* A preset is in force: no range is held (#4766). Choosing Custom again holds whatever the pickers
-               read, so nothing here keeps the old instants alive under the preset. */
-            _customRange.Clear();
+            RangePicker.SampleInterval = ViewerTimeRangeWindow.SampleIntervalFor(collector, _server.ServerId, overrides);
         }
-
-        /* Presets reload here; a custom range reloads off the picker changes (below), except the seeded
-           default above which is suppressed — so drive that one reload explicitly. */
-        if (!isCustom || FromDatePicker?.SelectedDate != null)
+        catch (Exception ex)
         {
-            await RefreshActiveInnerTabAsync();
+            ViewerLogger.Warn("ViewerServerTab", $"time range note failed | {ex.GetType().Name}: {ex.Message}");
         }
     }
 
-    private async void CustomDateRange_Changed(object sender, SelectionChangedEventArgs e)
+    /// <summary>
+    /// Sets the picker's "Data starts ..." note from a data-start probe a surface already awaited (#5562, the desktop twin
+    /// of the web's retention note): the same <c>floor</c> the surface's "Showing since" banner reads. No query of its own.
+    /// A null floor (the probe found nothing, or failed) clears the note.
+    /// </summary>
+    internal void RecordDataStart(DateTime? floor)
     {
-        if (!IsLoaded || _suppressRangeEvents)
+        if (RangePicker.DataStartUtc != floor)
         {
-            return;
-        }
-
-        if (FromDatePicker?.SelectedDate != null && ToDatePicker?.SelectedDate != null)
-        {
-            ApplyPickerEdit(sender);
-            await RefreshActiveInnerTabAsync();
+            RangePicker.DataStartUtc = floor;
         }
     }
 
-    private async void CustomTimeCombo_Changed(object sender, SelectionChangedEventArgs e)
+    /// <summary><see cref="DataStartOrNullAsync"/> that also feeds the picker's data-start note with its answer. Used by the
+    /// primary surface of each top-level tab.</summary>
+    private async Task<DateTime?> PrimaryDataStartAsync(Task<DateTime?> probe, string surface)
     {
-        if (!IsLoaded || _suppressRangeEvents)
-        {
-            return;
-        }
-
-        if (FromDatePicker?.SelectedDate != null && ToDatePicker?.SelectedDate != null)
-        {
-            ApplyPickerEdit(sender);
-            await RefreshActiveInnerTabAsync();
-        }
+        var floor = await DataStartOrNullAsync(probe, surface);
+        RecordDataStart(floor);
+        return floor;
     }
 
     private async void RefreshDataButton_Click(object sender, RoutedEventArgs e)
@@ -435,19 +291,12 @@ private void UpdateAutoRefreshInterval()
         };
     }
 
+
     private void ApplyTimeRangeToAll_Click(object sender, RoutedEventArgs e)
     {
-        /* The held instants go out, not the pickers' wall clock: every other tab draws them in its own server's
-           zone, so all of them window on the same period (#4766). */
-        DateTime? fromUtc = null;
-        DateTime? toUtc = null;
-        if (TimeRangeCombo.SelectedIndex == CustomRangeIndex && _customRange.IsCustom)
-        {
-            fromUtc = _customRange.FromUtc;
-            toUtc = _customRange.ToUtc;
-        }
-
-        ApplyTimeRangeRequested?.Invoke(this, TimeRangeCombo.SelectedIndex, fromUtc, toUtc);
+        /* A calendar period goes as the instants it names in THIS tab's zone, a fixed range as its held instants: every
+           other tab draws them in its own server's zone, so all of them window on the same period (#4766, #5562). */
+        ApplyTimeRangeRequested?.Invoke(this, ViewerTimeRangeWindow.ForBroadcast(RangePicker.Value, DateTime.UtcNow, TabDisplayZone));
     }
 
     // ── Time-display mode (Server / Local / UTC) ─────────────────────────────────────
@@ -483,10 +332,10 @@ internal async Task RefreshServerClockAsync()
                degrades gracefully to ~Local until server_properties.utc_offset_minutes is populated. */
         }
 
-        /* The pickers are a drawing of the held instants in this tab's zone, and the clock is what may just have
-           changed it (the first read after a range was applied from another tab, or a server that moved zone), so
-           draw them again. Nothing is drawn while a preset is selected (#4766). */
-        RenderCustomRange(TabDisplayZone);
+        /* The picker draws the held range in this tab's zone, and the clock is what may just have changed it (the
+           first read after a range was applied from another tab, or a server that moved zone), so draw it again. A
+           range that slides with now is redrawn from the clock too (#4766, #5562). */
+        RefreshRangePicker();
     }
 
     /// <summary>Pushes this tab's server clock onto the process-wide helper. Called before every render so
@@ -528,7 +377,7 @@ a cascade. */
         try
         {
             ViewerTimeHelper.CurrentDisplayMode = mode;
-            RenderCustomRange(ViewerTimeHelper.DisplayZoneFor(mode, _serverClock));
+            RefreshRangePicker();
         }
         finally
         {
@@ -566,8 +415,9 @@ public void SetDisplayModeSelection(TimeDisplayMode mode)
             }
 
             /* The mode is process-wide, so a range this tab holds is drawn in the new mode's zone here too,
-               not left showing the old mode's text until the tab reloads (#4766). */
-            RenderCustomRange(ViewerTimeHelper.DisplayZoneFor(mode, _serverClock));
+               not left showing the old mode's text until the tab reloads (#4766). The picker reads the zone from
+               ViewerTimeHelper.CurrentDisplayMode, which the caller has already set to this mode. */
+            RefreshRangePicker();
         }
         finally
         {
@@ -576,43 +426,21 @@ public void SetDisplayModeSelection(TimeDisplayMode mode)
     }
 
     /// <summary>
-    /// Applies a range chosen on another server tab (the "Apply to All" broadcast). The range arrives as
-    /// naive-UTC instants: this tab holds them and draws them in ITS zone, so every tab windows on the same period
-    /// whatever its server's clock (#4766). Sets the pickers and combo under the suppress guard so the copy
-    /// doesn't cascade multiple reloads, then, when this is the visible tab, drives exactly one reload of its
-    /// active inner tab. A hidden tab holds the range and reloads when it is selected, so it never puts its own
-    /// server's clock on the shared <see cref="ViewerTimeHelper"/> while another tab is on screen.
+    /// <summary>
+    /// Applies a range chosen on another server tab (the "Apply to All" broadcast). The range arrives as a spec whose
+    /// instants are already fixed where they must be (<see cref="ViewerTimeRangeWindow.ForBroadcast"/>): this tab holds
+    /// it and draws it in ITS zone, so every tab windows on the same period whatever its server's clock (#4766). Sets
+    /// the picker under the suppress guard so the copy doesn't cascade multiple reloads, then, when this is the
+    /// visible tab, drives exactly one reload of its active inner tab. A hidden tab holds the range and reloads when it
+    /// is selected, so it never puts its own server's clock on the shared <see cref="ViewerTimeHelper"/> while another
+    /// tab is on screen.
     /// </summary>
-    public void ApplyExternalTimeRange(int index, DateTime? customFromUtc, DateTime? customToUtc)
+    public void ApplyExternalTimeRange(TimeRangeSpec range)
     {
         _suppressRangeEvents = true;
         try
         {
-            var isCustom = index == CustomRangeIndex && customFromUtc.HasValue && customToUtc.HasValue;
-            var visibility = isCustom ? Visibility.Visible : Visibility.Collapsed;
-
-            if (FromDatePicker != null)
-            {
-                FromDatePicker.Visibility = visibility;
-                FromHourCombo.Visibility = visibility;
-                FromMinuteCombo.Visibility = visibility;
-                ToLabel.Visibility = visibility;
-                ToDatePicker.Visibility = visibility;
-                ToHourCombo.Visibility = visibility;
-                ToMinuteCombo.Visibility = visibility;
-            }
-
-            if (isCustom)
-            {
-                _customRange.Set(customFromUtc!.Value, customToUtc!.Value);
-                RenderCustomRange(TabDisplayZone);
-            }
-            else
-            {
-                _customRange.Clear();
-            }
-
-            TimeRangeCombo.SelectedIndex = index;
+            RangePicker.Value = range;
         }
         finally
         {
@@ -632,106 +460,21 @@ is selected (MainWindow's tab switch), and shows the range it now holds then. Sa
 
     /// <summary>
     /// Scopes the toolbar to an explicit naive-UTC <c>[from, to)</c> window — the Performance Calendar day
-    /// drill's "set the time window to that day" step. Selects "Custom Range", reveals the pickers, holds the
-    /// bounds and draws them in the active display mode's zone (<see cref="CustomRangeState.Render"/>), so
-    /// <see cref="GetWindowUtc"/> returns exactly the window given. Runs under <see cref="_suppressRangeEvents"/>
-    /// so it drives no reload of its own — the caller (the day drill) loads the target inner tab itself. Mirrors
-    /// <see cref="ApplyExternalTimeRange"/>'s picker manipulation, without the reload.
+    /// drill's "set the time window to that day" step. Holds the bounds as a fixed range and draws them in the active
+    /// display mode's zone, so <see cref="GetWindowUtc"/> returns exactly the window given. Runs under
+    /// <see cref="_suppressRangeEvents"/> so it drives no reload of its own — the caller (the day drill) loads the target
+    /// inner tab itself. Mirrors <see cref="ApplyExternalTimeRange"/>, without the reload.
     /// </summary>
     internal void SetToolbarWindowUtc(DateTime fromUtc, DateTime toUtc)
     {
-        _customRange.Set(fromUtc, toUtc);
-
         _suppressRangeEvents = true;
         try
         {
-            if (FromDatePicker != null)
-            {
-                FromDatePicker.Visibility = Visibility.Visible;
-                FromHourCombo.Visibility = Visibility.Visible;
-                FromMinuteCombo.Visibility = Visibility.Visible;
-                ToLabel.Visibility = Visibility.Visible;
-                ToDatePicker.Visibility = Visibility.Visible;
-                ToHourCombo.Visibility = Visibility.Visible;
-                ToMinuteCombo.Visibility = Visibility.Visible;
-            }
-
-            RenderCustomRange(TabDisplayZone);
-            TimeRangeCombo.SelectedIndex = CustomRangeIndex;
+            RangePicker.Value = TimeRangeSpec.FixedRange(fromUtc, toUtc);
         }
         finally
         {
             _suppressRangeEvents = false;
         }
     }
-
-    // ── Custom-range DatePicker calendar theming (viewer is fixed Dark) ───────────────
-
-    private void DatePicker_CalendarOpened(object sender, RoutedEventArgs e)
-    {
-        if (sender is not DatePicker datePicker)
-        {
-            return;
-        }
-
-        /* Defer so the popup's visual tree exists before we re-color it. */
-        Dispatcher.BeginInvoke(new Action(() =>
-        {
-            if (datePicker.Template.FindName("PART_Popup", datePicker) is Popup { Child: Calendar calendar })
-            {
-                ApplyDarkThemeToCalendar(calendar);
-            }
-        }));
-    }
-
-    private static void ApplyDarkThemeToCalendar(Calendar calendar)
-    {
-        var primaryBg = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#111217")!);
-        var fg = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#E4E6EB")!);
-        var borderBrush = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#2a2d35")!);
-
-        calendar.Background = primaryBg;
-        calendar.Foreground = fg;
-        calendar.BorderBrush = borderBrush;
-        ApplyDarkThemeRecursively(calendar, primaryBg, fg);
-    }
-
-    private static void ApplyDarkThemeRecursively(DependencyObject parent, Brush primaryBg, Brush fg)
-    {
-        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
-        {
-            var child = VisualTreeHelper.GetChild(parent, i);
-
-            switch (child)
-            {
-                case CalendarItem calendarItem:
-                    calendarItem.Background = primaryBg;
-                    calendarItem.Foreground = fg;
-                    break;
-                case CalendarDayButton dayButton:
-                    dayButton.Background = Brushes.Transparent;
-                    dayButton.Foreground = fg;
-                    break;
-                case CalendarButton calButton:
-                    calButton.Background = Brushes.Transparent;
-                    calButton.Foreground = fg;
-                    break;
-                case Button button:
-                    button.Background = Brushes.Transparent;
-                    button.Foreground = fg;
-                    break;
-                case TextBlock textBlock:
-                    textBlock.Foreground = fg;
-                    break;
-                case Border { Background: SolidColorBrush bg } border when bg.Color is { R: > 200, G: > 200, B: > 200 }:
-                    border.Background = primaryBg;
-                    break;
-                case Grid { Background: SolidColorBrush gridBg } grid when gridBg.Color is { R: > 200, G: > 200, B: > 200 }:
-                    grid.Background = primaryBg;
-                    break;
-            }
-
-            ApplyDarkThemeRecursively(child, primaryBg, fg);
-        }
-    }
 }
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml
index 785ade8155..ea6ea988a6 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml
@@ -490,30 +490,11 @@
                         </Grid>
                     </Border>
                 </Popup>
-                <ComboBox x:Name="TimeRangeCombo" SelectedIndex="3" Width="120" Margin="0,0,8,4"
-                          SelectionChanged="TimeRangeCombo_SelectionChanged"
-                          ToolTip="Time window every inner tab reads">
-                    <ComboBoxItem Content="Last 1 hour"/>
-                    <ComboBoxItem Content="Last 4 hours"/>
-                    <ComboBoxItem Content="Last 12 hours"/>
-                    <ComboBoxItem Content="Last 24 hours"/>
-                    <ComboBoxItem Content="Last 7 days"/>
-                    <ComboBoxItem Content="Custom Range"/>
-                </ComboBox>
-                <DatePicker x:Name="FromDatePicker" Width="120" Margin="0,0,2,4" Visibility="Collapsed"
-                            SelectedDateChanged="CustomDateRange_Changed" CalendarOpened="DatePicker_CalendarOpened"/>
-                <ComboBox x:Name="FromHourCombo" Width="70" Margin="0,0,2,4" Visibility="Collapsed"
-                          SelectionChanged="CustomTimeCombo_Changed" ToolTip="Hour"/>
-                <ComboBox x:Name="FromMinuteCombo" Width="60" Margin="0,0,2,4" Visibility="Collapsed"
-                          SelectionChanged="CustomTimeCombo_Changed" ToolTip="Minute"/>
-                <TextBlock x:Name="ToLabel" Text="to" VerticalAlignment="Center" Margin="4,0,4,0" Visibility="Collapsed"
-                           Foreground="{DynamicResource ForegroundBrush}"/>
-                <DatePicker x:Name="ToDatePicker" Width="120" Margin="0,0,2,4" Visibility="Collapsed"
-                            SelectedDateChanged="CustomDateRange_Changed" CalendarOpened="DatePicker_CalendarOpened"/>
-                <ComboBox x:Name="ToHourCombo" Width="70" Margin="0,0,2,4" Visibility="Collapsed"
-                          SelectionChanged="CustomTimeCombo_Changed" ToolTip="Hour"/>
-                <ComboBox x:Name="ToMinuteCombo" Width="60" Margin="0,0,8,4" Visibility="Collapsed"
-                          SelectionChanged="CustomTimeCombo_Changed" ToolTip="Minute"/>
+                <!-- #5562: the shared time range picker (presets from 5 minutes, calendar periods, typed or calendar-picked
+                     ranges) replaces the preset combo and the From/To date, hour and minute pickers. -->
+                <ui:TimeRangePicker x:Name="RangePicker" Margin="0,0,8,4" VerticalAlignment="Top"
+                                    RangeChanged="RangePicker_RangeChanged"
+                                    ToolTip="Time window every inner tab reads"/>
                 <Button Content="Apply to All" Click="ApplyTimeRangeToAll_Click" Padding="8,4" Margin="0,0,8,4"
                         ToolTip="Apply this time range to all open server tabs"/>
                 <TextBlock Text="Compare:" VerticalAlignment="Center" Margin="0,0,4,0"
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs
index 25b387383a..da07d353d9 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs
@@ -202,14 +202,12 @@ themed up front + hover. */
            range handler no-ops while IsLoaded is false, and the checkbox handler no-ops while
            _autoRefreshTimer is still null — so seeding drives no premature reload or timer churn. */
         var toolbarDefaults = preferences ?? new ViewerPreferences();
-        TimeRangeCombo.SelectedIndex = toolbarDefaults.DefaultTimeRangeIndex;
+        InitializeRangePicker(toolbarDefaults);
         AutoRefreshCheckBox.IsChecked = toolbarDefaults.AutoRefreshEnabled;
         AutoRefreshIntervalCombo.SelectedIndex = toolbarDefaults.AutoRefreshIntervalIndex;
 
-        /* Per-server toolbar (this wave): populate the custom-range hour/minute combos and start the
-           auto-refresh timer at the toolbar's interval (seeded above). The settable window these controls
-           drive replaces the removed 24-hour s_dataWindow constant. */
-        InitializeTimeComboBoxes();
+        /* Per-server toolbar (this wave): start the auto-refresh timer at the toolbar's interval (seeded above). The
+           settable window the shared time range picker drives replaces the removed 24-hour s_dataWindow constant. */
         InitializeAutoRefreshTimer();
 
         /* Seed the toolbar's Server/Local/UTC picker from the persisted global mode (MainWindow set
@@ -293,6 +291,11 @@ visible tab renders (the viewer's visible-only rule), so its offset wins. Loaded
                Health tab, which is why it went unnoticed. Badge it so it is discoverable from any tab. */
             await UpdatePermissionDeniedBadgeAsync();
 
+            /* #5562: redraw the picker's resolved range from the clock (a range that slides with now) and refresh its
+               "collected every N minutes" note for the inner tab on screen. Chrome: its own try/catch keeps it off the load path. */
+            RefreshRangePicker();
+            await UpdateSampleIntervalAsync();
+
             do
             {
                 _refreshRequested = false;
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
new file mode 100644
index 0000000000..a1e6f19241
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Collections.Generic;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Ui;
+
+namespace PerformanceMonitor.Darling.Viewer;
+
+/// <summary>
+/// The pure half of the Viewer's time range (#5562): how a <see cref="TimeRangeSpec"/> the shared picker holds becomes
+/// the naive-UTC window every inner tab reads, the whole hours the few integer readers still take, the legacy
+/// preset index old preference files hold, what "Apply to All" sends, and which collector a tab's chart is fed by (for
+/// the picker's "collected every N minutes" note). Nothing here reads the clock, the zone or a control, so a test pins
+/// each rule without a window (a <c>ViewerServerTab</c> needs the app's resources and cannot be built in a test).
+/// </summary>
+internal static class ViewerTimeRangeWindow
+{
+    /// <summary>The window a range that cannot be resolved right now (Today in its first minutes, which is under the
+    /// 5-minute floor) falls back to: the Viewer's historical 24 hours, so no surface is ever window-less.</summary>
+    internal static readonly TimeSpan FallbackSpan = TimeSpan.FromHours(24);
+
+    /// <summary>The window to read now: the range's start and end as naive UTC, and whether the end slides with the
+    /// clock. A live range (past N, since X, today) ends at <paramref name="nowUtc"/>; a fixed or finished calendar
+    /// period keeps its instants. No upper bound is applied: a long period reads what the data holds (#5562 R1).</summary>
+    internal static (DateTime StartUtc, DateTime EndUtc, bool IsLive) Window(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
+    {
+        ArgumentNullException.ThrowIfNull(spec);
+        ArgumentNullException.ThrowIfNull(zone);
+        if (spec.TryResolve(nowUtc, zone, out var range, out _) && range is not null)
+        {
+            return (range.StartUtc, range.EndUtc, range.IsLive);
+        }
+
+        return (nowUtc - FallbackSpan, nowUtc, true);
+    }
+
+    /// <summary>The whole hours a reader that still takes "hours back" is given for a window: rounded up, at least one,
+    /// so a 45-minute window reads as 1 hour rather than 0. A reader that can take the window's two instants should
+    /// (the Overview lanes do); this is for the ones that cannot.</summary>
+    internal static int HoursBack(DateTime startUtc, DateTime endUtc)
+    {
+        var hours = (int)Math.Ceiling((endUtc - startUtc).TotalHours);
+        return hours < 1 ? 1 : hours;
+    }
+
+    /// <summary>Legacy preset index (the old combo and the old preference file: 0=1h, 1=4h, 2=12h, 3=24h, 4=7d) to
+    /// hours back. Index 5 (Custom) and any stray value fall to the 24-hour default. Pure and static so the mapping is
+    /// unit-testable.</summary>
+    internal static int LegacyIndexToHours(int index) => index switch
+    {
+        0 => 1,
+        1 => 4,
+        2 => 12,
+        3 => 24,
+        4 => 168,
+        _ => 24,
+    };
+
+    /// <summary>The range a legacy preset index stands for: 1h, 4h, 12h, 1d, 1w (24 hours is "1d" and 168 is "1w").</summary>
+    internal static TimeRangeSpec FromLegacyIndex(int index)
+        => TimeRangePresets.FromLegacyHours(LegacyIndexToHours(index)) ?? TimeRangeSpec.Relative(FallbackSpan);
+
+    /// <summary>The legacy index nearest a range, so a preference file written now still opens on an older build:
+    /// 1h=0, 4h=1, 12h=2, 1d=3, 1w=4, and the historical default (3) for anything the old combo could not hold.</summary>
+    internal static int ToLegacyIndex(TimeRangeSpec spec)
+        => spec.Id switch
+        {
+            "1h" => 0,
+            "4h" => 1,
+            "12h" => 2,
+            "1d" => 3,
+            "1w" => 4,
+            _ => ViewerPreferences.DefaultTimeRangeIndexValue,
+        };
+
+    /// <summary>What "Apply to All" sends for a held range. A relative range and a fixed or since range go as they are
+    /// (every tab then windows on the same period, as #4766 settled). A calendar period is resolved ONCE here, in the
+    /// source tab's zone, and sent as the instants it names - or as a since range while it still runs (Today) - because
+    /// each tab draws its own server's clock and "Today" would otherwise mean a different day on each. A period that
+    /// cannot be resolved right now goes as it is.</summary>
+    internal static TimeRangeSpec ForBroadcast(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
+    {
+        ArgumentNullException.ThrowIfNull(spec);
+        if (spec.Kind != TimeRangeKind.Calendar || !spec.TryResolve(nowUtc, zone, out var range, out _) || range is null)
+        {
+            return spec;
+        }
+
+        return range.IsLive ? TimeRangeSpec.SinceInstant(range.StartUtc) : TimeRangeSpec.FixedRange(range.StartUtc, range.EndUtc);
+    }
+
+    /// <summary>The collector that feeds the first chart of a top-level inner tab, by the tab's header, or null for a tab
+    /// that has no single main collector (it then shows no sample-interval note). Names are
+    /// <see cref="CollectorScheduleDefaults"/> keys.</summary>
+    internal static string? MainCollectorFor(string? innerTabHeader) => innerTabHeader switch
+    {
+        "Overview" => "cpu_utilization",
+        "Wait Stats" => "wait_stats",
+        "Queries" => "query_stats",
+        "CPU" => "cpu_utilization",
+        "Memory" => "memory_stats",
+        "File I/O" => "file_io_stats",
+        "tempdb" => "tempdb_stats",
+        "Blocking" => "blocked_process_report",
+        _ => null,
+    };
+
+    /// <summary>How often <paramref name="collector"/> actually runs on this server: its fleet or per-server schedule
+    /// override if there is one, else the shipped default (<see cref="CollectorScheduleDefaults"/>). Null for a collector
+    /// that is not scheduled on a cadence (on load) or is not known, so the picker shows no note rather than a wrong one.</summary>
+    internal static TimeSpan? SampleIntervalFor(string? collector, int serverId, IEnumerable<CollectorScheduleRow>? overrides)
+    {
+        if (string.IsNullOrEmpty(collector))
+        {
+            return null;
+        }
+
+        var minutes = CollectorScheduleDefaults.ResolveEffectiveIntervalMinutes(collector, serverId, overrides);
+        return minutes is > 0 ? TimeSpan.FromMinutes(minutes.Value) : null;
+    }
+
+    /// <summary>The range a newly-opened tab starts on, from the persisted preference (a string id wins; the legacy
+    /// index stands in for a file written before the string existed).</summary>
+    internal static TimeRangeSpec DefaultFor(ViewerPreferences preferences)
+    {
+        ArgumentNullException.ThrowIfNull(preferences);
+        return TimeRangeSpec.TryFromId(preferences.DefaultTimeRange, out var spec) && spec is not null && IsPersistable(spec)
+            ? spec
+            : FromLegacyIndex(preferences.DefaultTimeRangeIndex);
+    }
+
+    /// <summary>True for a range that makes sense as a standing default: a rolling length or a calendar period. A fixed
+    /// or since range names concrete instants and stays unpersisted (as Custom always has).</summary>
+    internal static bool IsPersistable(TimeRangeSpec spec)
+        => spec.Kind is TimeRangeKind.Relative or TimeRangeKind.Calendar;
+}

From bc2ca9fc5ae9093670f90db3b674a4f0964a78f9 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:44:09 -0400
Subject: [PATCH 06/33] Web time range picker: grammar module, picker control
 and the server page's use of it (#5562)

time-range.js is the web twin of the shared model and runs all 100 rows of the shared fixture under Node. time-range-picker.js is the control: presets, calendar periods, a typed range that previews before Apply, a date and time pick, reach greying and the sample-interval and data-start notes. The server page swaps its preset list and datetime-local boxes for it; ranges under an hour are fetched as the whole hour and trimmed to the exact pair.
---
 .../Darling.Tests/DarlingWebAssetsTests.cs    |   1 +
 .../Darling.Tests/WebServerPageRangeTests.cs  |  25 +-
 Darling/Darling.Tests/WebTimeRangeTests.cs    | 300 ++++++
 Darling/Darling.Tests/time-range-harness.mjs  |  46 +
 .../time-range-picker-harness.mjs             | 260 ++++++
 .../web-kept-history-harness.mjs              |  32 +-
 .../wwwroot/css/time-range.css                |  70 ++
 .../wwwroot/index.html                        |   1 +
 .../wwwroot/js/pages/server.js                | 156 ++--
 .../wwwroot/js/time-range-picker.js           | 325 +++++++
 .../wwwroot/js/time-range.js                  | 873 ++++++++++++++++++
 11 files changed, 1988 insertions(+), 101 deletions(-)
 create mode 100644 Darling/Darling.Tests/WebTimeRangeTests.cs
 create mode 100644 Darling/Darling.Tests/time-range-harness.mjs
 create mode 100644 Darling/Darling.Tests/time-range-picker-harness.mjs
 create mode 100644 Darling/PerformanceMonitor.Darling.Service/wwwroot/css/time-range.css
 create mode 100644 Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
 create mode 100644 Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js

diff --git a/Darling/Darling.Tests/DarlingWebAssetsTests.cs b/Darling/Darling.Tests/DarlingWebAssetsTests.cs
index 41999e72eb..bdbc7f0584 100644
--- a/Darling/Darling.Tests/DarlingWebAssetsTests.cs
+++ b/Darling/Darling.Tests/DarlingWebAssetsTests.cs
@@ -40,6 +40,7 @@ public void Wwwroot_IndexHtml_IsCopiedToTheBuildOutput()
     [InlineData("css/theme.css")]
     [InlineData("css/app.css")]
     [InlineData("css/editor.css")]
+    [InlineData("css/time-range.css")]
     [InlineData("js/app.js")]
     [InlineData("js/util.js")]
     [InlineData("js/panels.js")]
diff --git a/Darling/Darling.Tests/WebServerPageRangeTests.cs b/Darling/Darling.Tests/WebServerPageRangeTests.cs
index ab835bea6f..9cd1655a58 100644
--- a/Darling/Darling.Tests/WebServerPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebServerPageRangeTests.cs
@@ -130,21 +130,19 @@ public void TheBlockingTabNote_NamesTheWidestOfferedRange()
         Assert.Single(notes, n => n.Contains("A Custom View can show more", System.StringComparison.Ordinal));
     }
 
-    /// <summary>The same rule read from <c>pages/server.js</c>: each preset is at least an hour and no wider than
-    /// <see cref="McpHelpers.MaxHoursBack"/>.</summary>
+    /// <summary>The same rule read from <c>pages/server.js</c> (#5562): the page declares how far its reads reach (no wider than
+    /// <see cref="McpHelpers.MaxHoursBack"/>), hands that reach to the picker so a longer range is greyed out, and derives the
+    /// whole-hour presets it reads as plain <c>hours</c> from the picker module's presets, never a list of its own.</summary>
     [Fact]
     public void TheOfferedRanges_InTheSource_AreNoWiderThanTheReadsTake()
     {
         var server = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server.js");
-        var options = Regex.Match(server, @"const RANGE_OPTIONS = \[(.*?)\];", RegexOptions.Singleline);
-        Assert.True(options.Success, "pages/server.js no longer declares RANGE_OPTIONS.");
-
-        var hours = Regex.Matches(options.Groups[1].Value, @"hours:\s*([0-9\s*]+),")
-            .Select(m => m.Groups[1].Value.Split('*').Aggregate(1, (product, factor) => product * int.Parse(factor.Trim())))
-            .ToArray();
-
-        Assert.NotEmpty(hours);
-        Assert.All(hours, h => Assert.InRange(h, 1, McpHelpers.MaxHoursBack));
+        var reach = Regex.Match(server, @"const PAGE_REACH_HOURS = ([0-9]+);");
+        Assert.True(reach.Success, "pages/server.js no longer declares PAGE_REACH_HOURS.");
+        Assert.InRange(int.Parse(reach.Groups[1].Value, CultureInfo.InvariantCulture), 1, McpHelpers.MaxHoursBack);
+        Assert.Contains("reachHours: PAGE_REACH_HOURS", server, System.StringComparison.Ordinal);
+        Assert.Matches(@"const RANGE_OPTIONS = ROLLING_PRESETS", server);
+        Assert.Contains("hours <= PAGE_REACH_HOURS", server, System.StringComparison.Ordinal);
     }
 
     /// <summary>A custom start and end maps to the reads' window: <c>as_of</c> is the end and <c>hours</c> is the span rounded
@@ -161,7 +159,10 @@ public void ACustomRange_MapsToAsOfAndWholeHours_AndRefusesWhatNoReadTakes()
         Assert.Equal("2026-01-02T10:30:00.000Z", rounded.GetProperty("asOf").GetString());
         Assert.False(rounded.GetProperty("live").GetBoolean());
         Assert.Equal(4, found.GetProperty("exact").GetProperty("hours").GetInt32());
-        Assert.Contains("at least one hour", found.GetProperty("subHour").GetProperty("error").GetString());
+        var subHour = found.GetProperty("subHour");
+        Assert.Equal(1, subHour.GetProperty("hours").GetInt32());
+        Assert.Equal("2026-01-02T10:30:00.000Z", subHour.GetProperty("asOf").GetString());
+        Assert.Contains("shortest range is 5 minutes", found.GetProperty("tooShort").GetProperty("error").GetString());
         Assert.Contains("after the start", found.GetProperty("reversed").GetProperty("error").GetString());
         Assert.Contains("future", found.GetProperty("future").GetProperty("error").GetString());
         Assert.Contains("7 days", found.GetProperty("tooWide").GetProperty("error").GetString());
diff --git a/Darling/Darling.Tests/WebTimeRangeTests.cs b/Darling/Darling.Tests/WebTimeRangeTests.cs
new file mode 100644
index 0000000000..0fa2072dab
--- /dev/null
+++ b/Darling/Darling.Tests/WebTimeRangeTests.cs
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Text.Json;
+using Xunit;
+using static Darling.Tests.RepoFile;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// The web time range picker (#5562) under Node, skipped where Node is not installed. The grammar module
+/// (<c>wwwroot/js/time-range.js</c>) runs every row of the shared fixture the C# parser runs
+/// (<c>Fixtures/time-range-cases.json</c>), so the two cannot drift. The picker's DOM
+/// (<c>time-range-picker.js</c>) runs in a stand-in DOM, and the server page's use of it runs through the kept-history harness.
+/// </summary>
+public sealed class WebTimeRangeTests
+{
+    private static readonly string s_jsDir = PathTo("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js");
+
+    /// <summary>Runs a harness script and parses the one line of JSON it prints; skips when Node is missing.</summary>
+    private static bool TryRunNode(string script, out JsonElement result, params string[] args)
+    {
+        result = default;
+        var psi = new ProcessStartInfo("node") { RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false };
+        psi.ArgumentList.Add(PathTo("Darling", "Darling.Tests", script));
+        foreach (var arg in args)
+        {
+            psi.ArgumentList.Add(arg);
+        }
+
+        Process proc;
+        try
+        {
+            proc = Process.Start(psi)!;
+        }
+        catch (Win32Exception)
+        {
+            Assert.Skip("Node is not installed, so the shipped page script cannot be run.");
+            return false;
+        }
+
+        using (proc)
+        {
+            var error = proc.StandardError.ReadToEndAsync();
+            var output = proc.StandardOutput.ReadToEnd().Trim();
+            if (!proc.WaitForExit(30000))
+            {
+                proc.Kill(entireProcessTree: true);
+                Assert.Fail("the harness " + script + " did not finish in 30 s");
+            }
+
+            Assert.True(proc.ExitCode == 0, "the harness " + script + " failed: " + error.Result);
+            using var doc = JsonDocument.Parse(output);
+            result = doc.RootElement.Clone();
+            return true;
+        }
+    }
+
+    /// <summary>Every row of the shared fixture, through the web module: start, end, live, the echo text and the error code.</summary>
+    [Fact]
+    public void TheWebModule_RunsEveryRowOfTheSharedFixture()
+    {
+        var fixturePath = PathTo("Darling", "Darling.Tests", "Fixtures", "time-range-cases.json");
+        if (!TryRunNode("time-range-harness.mjs", out var r, s_jsDir, fixturePath)) return;
+
+        using var fixture = JsonDocument.Parse(System.IO.File.ReadAllText(fixturePath));
+        var rows = fixture.RootElement.GetProperty("cases").GetArrayLength();
+        Assert.True(rows >= 100, "The shared fixture has " + rows + " rows; it held 100 when the web module was written.");
+        Assert.Equal(rows, r.GetProperty("total").GetInt32());
+        Assert.Equal(fixture.RootElement.GetProperty("minimumSpanMinutes").GetInt32(), r.GetProperty("minimumSpanMinutes").GetInt32());
+
+        var failures = r.GetProperty("failures").EnumerateArray().Select(e => e.GetString()!).ToArray();
+        Assert.True(failures.Length == 0, failures.Length + " fixture rows differ in the web module:\n" + string.Join("\n", failures.Take(20)));
+        Assert.Equal(rows, r.GetProperty("passed").GetInt32());
+    }
+
+    private static string[] Strings(JsonElement node, string name) =>
+        node.GetProperty(name).EnumerateArray().Select(e => e.GetString()!).ToArray();
+
+    /// <summary>The closed picker: the button names the range, the resolved start, end and zone sit beside it, and the reads get a
+    /// whole-hours window.</summary>
+    [Fact]
+    public void TheClosedPicker_NamesTheRange_AndShowsTheResolvedStartEndAndZone()
+    {
+        if (!TryRunNode("time-range-picker-harness.mjs", out var r, s_jsDir)) return;
+
+        var closed = r.GetProperty("closed");
+        Assert.Equal("Past day", closed.GetProperty("button").GetString());
+        Assert.Equal("Oct 7, 7:01 am - Oct 8, 7:01 am (UTC-04:00)", closed.GetProperty("detail").GetString());
+        Assert.Equal("Time range: Past day, Oct 7, 7:01 am - Oct 8, 7:01 am (UTC-04:00)", closed.GetProperty("ariaLabel").GetString());
+        Assert.Equal("false", closed.GetProperty("expanded").GetString());
+        Assert.Equal("dialog", closed.GetProperty("haspopup").GetString());
+        Assert.Equal(24, closed.GetProperty("windowHours").GetInt32());
+        Assert.Equal(JsonValueKind.Null, closed.GetProperty("windowAsOf").ValueKind);
+    }
+
+    /// <summary>The popup lists the nine short presets and the eight calendar periods with their current lengths, greys out what is
+    /// longer than the reach with the reason, and carries accessible names.</summary>
+    [Fact]
+    public void TheOpenPopup_ListsEveryPresetAndPeriod_AndGreysOutWhatTheReadsCannotReach()
+    {
+        if (!TryRunNode("time-range-picker-harness.mjs", out var r, s_jsDir)) return;
+
+        var open = r.GetProperty("open");
+        Assert.Equal("true", open.GetProperty("expanded").GetString());
+        Assert.Equal("dialog", open.GetProperty("role").GetString());
+        Assert.Equal("Time range options", open.GetProperty("dialogLabel").GetString());
+        Assert.Equal("Type a time range", open.GetProperty("textLabel").GetString());
+        Assert.Equal(new[] { "Range start", "Range end" }, Strings(open, "pickLabels"));
+        Assert.True(open.GetProperty("focusedText").GetBoolean());
+        Assert.Equal(1, open.GetProperty("documentMousedownListeners").GetInt32());
+        Assert.Equal("2026-10-07T07:01", open.GetProperty("from").GetString());
+        Assert.Equal("2026-10-08T07:01", open.GetProperty("to").GetString());
+
+        var names = open.GetProperty("items").EnumerateArray().Select(i => i.GetProperty("name").GetString()).ToArray();
+        Assert.Equal(
+            new[]
+            {
+                "Past 5 minutes", "Past 15 minutes", "Past 30 minutes", "Past hour", "Past 4 hours", "Past day", "Past 2 days", "Past week", "Past 30 days",
+                "Today", "Yesterday", "Week to Date", "Previous Week", "Month to Date", "Previous Month", "Year to Date", "Previous Year",
+            },
+            names);
+
+        /* At Oct 8 7:01 am the week so far is 3d, last week is exactly the 7 days the reads reach, and everything longer is greyed out. */
+        var lengths = open.GetProperty("items").EnumerateArray().ToDictionary(i => i.GetProperty("name").GetString()!, i => i.GetProperty("length").GetString());
+        Assert.Equal("7h 1m", lengths["Today"]);
+        Assert.Equal("1d", lengths["Yesterday"]);
+        Assert.Equal("3d", lengths["Week to Date"]);
+        Assert.Equal("7d", lengths["Previous Week"]);
+        var disabled = Strings(open, "disabled").Select(d => d.Split(" | ")[0]).ToArray();
+        Assert.Equal(new[] { "Past 30 days", "Month to Date", "Previous Month", "Year to Date", "Previous Year" }, disabled);
+        Assert.All(Strings(open, "disabled"), d => Assert.Contains("reach at most 7 days", d));
+        Assert.Contains(open.GetProperty("items").EnumerateArray(), i => i.GetProperty("name").GetString() == "Past day" && i.GetProperty("pressed").GetString() == "true");
+    }
+
+    /// <summary>Typing shows the parsed range before Apply; Enter applies; a range under five minutes, past the reach, or nonsense is
+    /// refused with the reason, Apply is disabled and Enter does nothing.</summary>
+    [Fact]
+    public void TheTextBox_PreviewsBeforeApply_AppliesOnEnter_AndRefusesWithTheReason()
+    {
+        if (!TryRunNode("time-range-picker-harness.mjs", out var r, s_jsDir)) return;
+
+        var ok = r.GetProperty("typedOk");
+        Assert.Equal("45m  Oct 8, 6:16 am - Oct 8, 7:01 am (UTC-04:00)", ok.GetProperty("preview").GetString());
+        Assert.Contains("trp-ok", ok.GetProperty("previewClass").GetString());
+        Assert.False(ok.GetProperty("applyDisabled").GetBoolean());
+
+        var applied = r.GetProperty("typedApplied");
+        var change = Assert.Single(applied.GetProperty("changes").EnumerateArray());
+        Assert.Equal("45m", change.GetProperty("id").GetString());
+        Assert.Equal("Past 45 minutes", applied.GetProperty("button").GetString());
+        Assert.False(applied.GetProperty("open").GetBoolean());
+        Assert.Equal(0, applied.GetProperty("docListeners").GetInt32());
+        /* A sub-hour range is read as the whole hour that holds it, live (no end time), and trimmed by the page. */
+        Assert.Equal(1, applied.GetProperty("window").GetProperty("hours").GetInt32());
+        Assert.Equal(JsonValueKind.Null, applied.GetProperty("window").GetProperty("asOf").ValueKind);
+
+        Assert.Equal("That range is only 3m long. The shortest range is 5 minutes.", r.GetProperty("tooShort").GetProperty("preview").GetString());
+        Assert.True(r.GetProperty("tooShort").GetProperty("applyDisabled").GetBoolean());
+        Assert.Equal("This page's reads reach at most 7 days back.", r.GetProperty("tooLong").GetProperty("preview").GetString());
+        Assert.Contains("trp-error", r.GetProperty("nonsense").GetProperty("previewClass").GetString());
+        Assert.True(r.GetProperty("nonsense").GetProperty("applyDisabled").GetBoolean());
+        Assert.True(r.GetProperty("empty").GetProperty("applyDisabled").GetBoolean());
+        Assert.Equal(0, r.GetProperty("refusedChanges").GetInt32());
+        Assert.True(r.GetProperty("stillOpen").GetBoolean());
+    }
+
+    /// <summary>Esc closes the popup from the text box and returns focus to the button; a press outside closes it without a change,
+    /// one inside does not; the document listener exists only while the popup is open.</summary>
+    [Fact]
+    public void TheKeyboardAndFocus_EscClosesAndReturnsFocus_AndTheDocumentListenerGoesWithThePopup()
+    {
+        if (!TryRunNode("time-range-picker-harness.mjs", out var r, s_jsDir)) return;
+
+        var esc = r.GetProperty("escape");
+        Assert.False(esc.GetProperty("open").GetBoolean());
+        Assert.True(esc.GetProperty("focusOnButton").GetBoolean());
+        Assert.Equal("false", esc.GetProperty("expanded").GetString());
+        Assert.Equal(0, esc.GetProperty("popups").GetInt32());
+        Assert.Equal(0, esc.GetProperty("docListeners").GetInt32());
+
+        var outside = r.GetProperty("outside");
+        Assert.True(outside.GetProperty("stillOpenAfterInside").GetBoolean());
+        Assert.False(outside.GetProperty("openAfterOutside").GetBoolean());
+        Assert.Equal(0, outside.GetProperty("changes").GetInt32());
+        Assert.Equal(0, outside.GetProperty("docListeners").GetInt32());
+    }
+
+    /// <summary>A preset applies at once, a greyed-out one does nothing, a calendar period holds its spec; the date boxes write the
+    /// typed form and preview it.</summary>
+    [Fact]
+    public void ThePresetsAndThePick_ApplyHoldAndPreview()
+    {
+        if (!TryRunNode("time-range-picker-harness.mjs", out var r, s_jsDir)) return;
+
+        var presets = r.GetProperty("presets");
+        Assert.Equal("Past 15 minutes", presets.GetProperty("afterPreset").GetProperty("button").GetString());
+        Assert.Equal("15m", Assert.Single(presets.GetProperty("afterPreset").GetProperty("changes").EnumerateArray()).GetProperty("id").GetString());
+        Assert.Equal(1, presets.GetProperty("afterDisabled").GetProperty("changes").GetInt32());
+        Assert.True(presets.GetProperty("afterDisabled").GetProperty("open").GetBoolean());
+        var period = presets.GetProperty("afterPeriod");
+        Assert.Equal("Previous Week", period.GetProperty("button").GetString());
+        Assert.Equal("Sep 28, 12:00 am - Oct 5, 12:00 am (UTC-04:00)", period.GetProperty("detail").GetString());
+        Assert.Equal(168, period.GetProperty("window").GetProperty("hours").GetInt32());
+        Assert.Equal("2026-10-05T04:00:00.000Z", period.GetProperty("window").GetProperty("asOf").GetString());
+
+        var picked = r.GetProperty("picked");
+        Assert.Equal("2026-10-01 13:00 - 2026-10-01 15:00", picked.GetProperty("text").GetString());
+        Assert.Equal("2h  Oct 1, 1:00 pm - Oct 1, 3:00 pm (UTC-04:00)", picked.GetProperty("preview").GetString());
+    }
+
+    /// <summary>Compact moves the detail into the tooltip; the sample-interval note shows when the span holds fewer than three samples
+    /// and the data-start note when the range starts well before the data; select() refuses a range the page cannot take; the catalog's
+    /// max_hours is the reach; a live range slides on refresh.</summary>
+    [Fact]
+    public void TheNotesTheReachAndTheClock_FollowTheirInputs()
+    {
+        if (!TryRunNode("time-range-picker-harness.mjs", out var r, s_jsDir)) return;
+
+        Assert.Equal(string.Empty, r.GetProperty("compact").GetProperty("detail").GetString());
+        Assert.Equal("Past day, Oct 7, 7:01 am - Oct 8, 7:01 am (UTC-04:00)", r.GetProperty("compact").GetProperty("title").GetString());
+        Assert.Equal("Data here is collected every 5 minutes.", r.GetProperty("notes").GetProperty("short").GetString());
+        Assert.Equal("Data starts Oct 8, 5:01 am", r.GetProperty("notes").GetProperty("wide").GetString());
+
+        var select = r.GetProperty("select");
+        Assert.Contains("7 days", select.GetProperty("tooLong").GetString());
+        Assert.Contains("shortest range is 5 minutes", select.GetProperty("tooShort").GetString());
+        Assert.Equal(JsonValueKind.Null, select.GetProperty("ok").ValueKind);
+        Assert.Equal(new[] { "1h" }, Strings(select, "changes"));
+
+        var reach = r.GetProperty("reach");
+        Assert.Equal(2160, reach.GetProperty("reach").GetInt32());
+        Assert.Equal(168, reach.GetProperty("none").GetInt32());
+        Assert.Equal(168, reach.GetProperty("absent").GetInt32());
+        Assert.Equal(new[] { "Year to Date", "Previous Year" }, Strings(reach, "items"));
+
+        var slides = r.GetProperty("slides");
+        Assert.Equal("Oct 8, 6:01 am - Oct 8, 7:01 am (UTC-04:00)", slides.GetProperty("first").GetString());
+        Assert.Equal("Oct 8, 7:01 am - Oct 8, 8:01 am (UTC-04:00)", slides.GetProperty("second").GetString());
+        Assert.Equal("Previous Month", slides.GetProperty("afterSetSpec").GetString());
+        Assert.Equal("previous-month", slides.GetProperty("specId").GetString());
+    }
+
+    /// <summary>On the server page a range under an hour is fetched as the whole hour that holds it (the reads take integer hours) with
+    /// the range's end as <c>as_of</c>, then trimmed to the exact pair; the label says where the hour's totals begin.</summary>
+    [Fact]
+    public void ARangeUnderAnHour_IsFetchedAsTheWholeHourAndTrimmedToTheExactPair()
+    {
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("pickerSubHour", out var r)) return;
+
+        var found = r.GetProperty("found");
+        Assert.Equal(JsonValueKind.Null, found.GetProperty("err").ValueKind);
+        Assert.Equal(1, found.GetProperty("hours").GetInt32());
+        Assert.True(found.GetProperty("custom").GetBoolean());
+        Assert.Equal("/api/read/get_cpu_utilization?server=SRV1&hours=1&as_of=2026-01-02T10%3A30%3A00.000Z", Assert.Single(Strings(found, "reads")));
+        /* The five rows run 06:00 to 11:00; the picked 10:00 to 10:30 holds the 10:00 row only. */
+        Assert.Equal(1, found.GetProperty("rows").GetInt32());
+        Assert.Contains("totals and rankings aggregate from", found.GetProperty("label").GetString());
+    }
+
+    /// <summary>Every preset and calendar period, held for a server: the whole-hour presets within the reach are the page's own range
+    /// (no trimming), the sub-hour presets and the periods are custom ranges, and what is longer than 7 days is refused and leaves the
+    /// range as it was.</summary>
+    [Fact]
+    public void EveryPresetAndPeriod_IsHeldOrRefusedByTheServerPage()
+    {
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("pickerPresetsLocal:America/New_York", out var r)) return;
+
+        var found = r.GetProperty("found");
+        foreach (var id in new[] { "1h", "4h", "1d", "2d", "1w" })
+        {
+            Assert.Equal(JsonValueKind.Null, found.GetProperty(id).GetProperty("err").ValueKind);
+            Assert.False(found.GetProperty(id).GetProperty("custom").GetBoolean(), id + " is a whole-hour preset and needs no trimming.");
+        }
+
+        Assert.Equal(48, found.GetProperty("2d").GetProperty("hours").GetInt32());
+        Assert.Equal("last 7 days", found.GetProperty("1w").GetProperty("label").GetString());
+        foreach (var id in new[] { "5m", "15m", "30m", "today", "yesterday", "week-to-date", "previous-week" })
+        {
+            Assert.Equal(JsonValueKind.Null, found.GetProperty(id).GetProperty("err").ValueKind);
+            Assert.True(found.GetProperty(id).GetProperty("custom").GetBoolean(), id + " is fetched as whole hours and trimmed.");
+        }
+
+        Assert.Equal(1, found.GetProperty("5m").GetProperty("hours").GetInt32());
+        Assert.Equal(1, found.GetProperty("30m").GetProperty("hours").GetInt32());
+        Assert.Equal(168, found.GetProperty("previous-week").GetProperty("hours").GetInt32());
+        foreach (var id in new[] { "1mo", "month-to-date", "previous-month", "year-to-date", "previous-year" })
+        {
+            Assert.Contains("7 days", found.GetProperty(id).GetProperty("err").GetString());
+        }
+    }
+}
diff --git a/Darling/Darling.Tests/time-range-harness.mjs b/Darling/Darling.Tests/time-range-harness.mjs
new file mode 100644
index 0000000000..cd903b88b9
--- /dev/null
+++ b/Darling/Darling.Tests/time-range-harness.mjs
@@ -0,0 +1,46 @@
+/* Runs every case in Fixtures/time-range-cases.json against the web module wwwroot/js/time-range.js (#5562) and prints one
+   line of JSON: { total, passed, failures: [ "<case name>: <what differed>" ] }. WebTimeRangeFixtureTests starts it as
+       node time-range-harness.mjs <path to wwwroot/js> <path to time-range-cases.json>
+   The module is pure (no DOM, no clock), so it is copied into a scratch folder beside a package.json that marks it as an ES
+   module and imported there. Each case names its own IANA zone and its own now: the module takes both as arguments, so no
+   process zone is set and the run does not depend on the machine's. */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const [jsDir, fixturePath] = process.argv.slice(-2);
+
+const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "time-range-"));
+let mod;
+try {
+  fs.cpSync(jsDir, scratch, { recursive: true });
+  fs.writeFileSync(path.join(scratch, "package.json"), '{ "type": "module" }');
+  mod = await import(pathToFileURL(path.join(scratch, "time-range.js")).href);
+} finally {
+  fs.rmSync(scratch, { recursive: true, force: true });
+}
+
+const fixture = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+const failures = [];
+let passed = 0;
+
+for (const c of fixture.cases) {
+  const problems = [];
+  const r = mod.parseRange(c.input, Date.parse(c.now), c.zone);
+  if (c.error) {
+    if (r.ok) problems.push("expected error " + c.error + " but got " + r.echo);
+    else if (r.errorCode !== c.error) problems.push("error code " + r.errorCode + " (" + r.error + "), expected " + c.error);
+  } else if (!r.ok) {
+    problems.push("refused with " + r.errorCode + " (" + r.error + ")");
+  } else {
+    if (r.range.startMs !== Date.parse(c.start)) problems.push("start " + new Date(r.range.startMs).toISOString() + ", expected " + c.start);
+    if (r.range.endMs !== Date.parse(c.end)) problems.push("end " + new Date(r.range.endMs).toISOString() + ", expected " + c.end);
+    if (r.range.live !== c.live) problems.push("live " + r.range.live + ", expected " + c.live);
+    if (r.echo !== c.echo) problems.push("echo '" + r.echo + "', expected '" + c.echo + "'");
+  }
+  if (problems.length === 0) passed++;
+  else failures.push(c.name + " [" + c.input + " @ " + c.zone + "]: " + problems.join("; "));
+}
+
+console.log(JSON.stringify({ total: fixture.cases.length, passed, minimumSpanMinutes: fixture.minimumSpanMinutes, failures }));
diff --git a/Darling/Darling.Tests/time-range-picker-harness.mjs b/Darling/Darling.Tests/time-range-picker-harness.mjs
new file mode 100644
index 0000000000..51a8d7ac46
--- /dev/null
+++ b/Darling/Darling.Tests/time-range-picker-harness.mjs
@@ -0,0 +1,260 @@
+/* Drives the web time range picker (wwwroot/js/time-range-picker.js, #5562) in a small stand-in DOM and prints what it did as one
+   line of JSON. WebTimeRangePickerTests starts it as
+       node time-range-picker-harness.mjs <path to wwwroot/js>
+   The js tree is copied into a scratch folder (so util.js's `el` builder, the picker's one import beside time-range.js, loads as an
+   ES module) and imported. The DOM is a node tree of plain objects that can fire events up through their parents; the clock and the
+   zone are the picker's own options, so the run does not depend on the machine's. */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const jsDir = process.argv[process.argv.length - 1];
+
+class FakeEl {
+  constructor(tag, text) {
+    this.tag = tag;
+    this.children = [];
+    this.attrs = {};
+    this.dataset = {};
+    this.style = {};
+    this.listeners = {};
+    this.parentNode = null;
+    this.className = "";
+    this.value = "";
+    this.disabled = false;
+    this.text = text == null ? null : String(text);
+  }
+  get firstChild() {
+    return this.children[0] || null;
+  }
+  appendChild(child) {
+    child.parentNode = this;
+    this.children.push(child);
+    return child;
+  }
+  removeChild(child) {
+    const i = this.children.indexOf(child);
+    if (i >= 0) this.children.splice(i, 1);
+    child.parentNode = null;
+    return child;
+  }
+  contains(other) {
+    for (let n = other; n; n = n.parentNode) if (n === this) return true;
+    return false;
+  }
+  setAttribute(name, value) {
+    this.attrs[name] = String(value);
+  }
+  getAttribute(name) {
+    return name in this.attrs ? this.attrs[name] : null;
+  }
+  addEventListener(type, fn) {
+    (this.listeners[type] ||= []).push(fn);
+  }
+  focus() {
+    document.activeElement = this;
+  }
+  set textContent(value) {
+    this.children = [];
+    this.text = String(value);
+  }
+  get textContent() {
+    return (this.text || "") + this.children.map((c) => c.textContent).join("");
+  }
+}
+
+const documentListeners = {};
+globalThis.Node = FakeEl;
+globalThis.document = {
+  activeElement: null,
+  createElement: (tag) => new FakeEl(tag),
+  createElementNS: (ns, tag) => new FakeEl(tag),
+  createTextNode: (text) => new FakeEl("#text", text),
+  addEventListener: (type, fn) => (documentListeners[type] ||= []).push(fn),
+  removeEventListener: (type, fn) => {
+    const list = documentListeners[type] || [];
+    const i = list.indexOf(fn);
+    if (i >= 0) list.splice(i, 1);
+  },
+};
+
+/* Fire an event at a node and let it bubble up through its parents, unless a listener stops it. */
+function fire(target, type, extra = {}) {
+  let stopped = false;
+  const event = { type, target, key: extra.key, preventDefault() {}, stopPropagation() { stopped = true; }, ...extra };
+  for (let n = target; n && !stopped; n = n.parentNode) for (const fn of n.listeners[type] || []) fn(event);
+  return event;
+}
+const walkAll = (root, test, out = []) => {
+  if (test(root)) out.push(root);
+  root.children.forEach((c) => walkAll(c, test, out));
+  return out;
+};
+const byClass = (root, cls) => walkAll(root, (n) => (n.className || "").split(" ").includes(cls));
+const text = (node) => (node ? node.textContent : null);
+
+const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "time-range-picker-"));
+let picker;
+let tr;
+try {
+  fs.cpSync(jsDir, scratch, { recursive: true });
+  fs.writeFileSync(path.join(scratch, "package.json"), '{ "type": "module" }');
+  picker = await import(pathToFileURL(path.join(scratch, "time-range-picker.js")).href);
+  tr = await import(pathToFileURL(path.join(scratch, "time-range.js")).href);
+} finally {
+  fs.rmSync(scratch, { recursive: true, force: true });
+}
+
+const NOW = Date.parse("2026-10-08T11:01:00Z");
+const ZONE = "America/New_York";
+const make = (extra = {}) => {
+  documentListeners.mousedown = [];
+  const changes = [];
+  const p = picker.timeRangePicker({ zone: ZONE, now: () => NOW, onChange: (spec, range) => changes.push({ id: tr.specId(spec), label: range.label }), ...extra });
+  const root = new FakeEl("div");
+  root.appendChild(p.node);
+  return { p, root, changes, button: byClass(p.node, "trp-button")[0] };
+};
+const items = (root) => byClass(root, "trp-item").map((b) => ({ name: text(byClass(b, "trp-item-name")[0]), length: text(byClass(b, "trp-item-length")[0]), why: text(byClass(b, "trp-item-why")[0]), disabled: b.attrs["aria-disabled"] === "true", pressed: b.attrs["aria-pressed"] }));
+const itemNamed = (root, name) => byClass(root, "trp-item").find((b) => text(byClass(b, "trp-item-name")[0]) === name);
+const typeInto = (root, value) => {
+  const box = byClass(root, "trp-text")[0];
+  box.value = value;
+  fire(box, "input");
+  return { preview: text(byClass(root, "trp-preview")[0]), previewClass: byClass(root, "trp-preview")[0].className, applyDisabled: byClass(root, "btn")[0].disabled };
+};
+
+const found = {};
+
+/* 1. The closed picker: the button names the range, the detail has the resolved start, end and zone. */
+{
+  const { p, button } = make();
+  const detail = byClass(p.node, "trp-detail")[0];
+  found.closed = { button: text(button), detail: text(detail), ariaLabel: button.attrs["aria-label"], expanded: button.attrs["aria-expanded"], haspopup: button.attrs["aria-haspopup"], windowHours: p.window().hours, windowAsOf: p.window().asOf };
+}
+
+/* 2. Opening: presets, calendar periods with their current lengths, the reach greying the long ones out with the reason. */
+{
+  const { p, root, button } = make();
+  fire(button, "click");
+  const popup = byClass(root, "trp-popup")[0];
+  found.open = {
+    disabled: items(root).filter((i) => i.disabled).map((i) => i.name + ' | ' + i.why),
+    expanded: button.attrs["aria-expanded"],
+    role: popup.attrs.role,
+    dialogLabel: popup.attrs["aria-label"],
+    items: items(root),
+    textLabel: byClass(root, "trp-text")[0].attrs["aria-label"],
+    pickLabels: byClass(root, "trp-pick").map((b) => b.attrs["aria-label"]),
+    documentMousedownListeners: (documentListeners.mousedown || []).length,
+    focusedText: document.activeElement === byClass(root, "trp-text")[0],
+    from: byClass(root, "trp-pick")[0].value,
+    to: byClass(root, "trp-pick")[1].value,
+  };
+  void p;
+}
+
+/* 3. Typing shows the parsed range before Apply; Enter applies it. */
+{
+  const { p, root, changes, button } = make();
+  fire(button, "click");
+  found.typedOk = typeInto(root, "45m");
+  const box = byClass(root, "trp-text")[0];
+  fire(box, "keydown", { key: "Enter" });
+  found.typedApplied = { changes, button: text(button), open: p.isOpen(), expanded: button.attrs["aria-expanded"], docListeners: (documentListeners.mousedown || []).length, window: p.window() };
+}
+
+/* 4. Refusals are shown and Enter does nothing: under 5 minutes, past the reach, nonsense. */
+{
+  const { p, root, changes, button } = make();
+  fire(button, "click");
+  found.tooShort = typeInto(root, "3m");
+  fire(byClass(root, "trp-text")[0], "keydown", { key: "Enter" });
+  found.tooLong = typeInto(root, "last month");
+  fire(byClass(root, "trp-text")[0], "keydown", { key: "Enter" });
+  found.nonsense = typeInto(root, "banana");
+  found.empty = typeInto(root, "");
+  found.refusedChanges = changes.length;
+  found.stillOpen = p.isOpen();
+}
+
+/* 5. Esc closes and returns focus to the button, from the text box (the key bubbles) and from the button. */
+{
+  const { p, root, button } = make();
+  fire(button, "click");
+  fire(byClass(root, "trp-text")[0], "keydown", { key: "Escape" });
+  found.escape = { open: p.isOpen(), focusOnButton: document.activeElement === button, expanded: button.attrs["aria-expanded"], popups: byClass(root, "trp-popup").length, docListeners: (documentListeners.mousedown || []).length };
+}
+
+/* 6. A press outside closes the popup without raising a change; one inside does not. */
+{
+  const { p, root, changes, button } = make();
+  fire(button, "click");
+  const inside = (documentListeners.mousedown || [])[0];
+  inside({ target: byClass(root, "trp-text")[0] });
+  const stillOpen = p.isOpen();
+  inside({ target: new FakeEl("div") });
+  found.outside = { stillOpenAfterInside: stillOpen, openAfterOutside: p.isOpen(), changes: changes.length, docListeners: (documentListeners.mousedown || []).length };
+}
+
+/* 7. A preset applies at once; a greyed-out one does nothing; a calendar period holds its spec. */
+{
+  const { p, root, changes, button } = make();
+  fire(button, "click");
+  fire(itemNamed(root, "Past 15 minutes"), "click");
+  const afterPreset = { changes: [...changes], button: text(button), open: p.isOpen() };
+  fire(button, "click");
+  fire(itemNamed(root, "Past 30 days"), "click");
+  const afterDisabled = { changes: changes.length, open: p.isOpen() };
+  fire(itemNamed(root, "Previous Week"), "click");
+  found.presets = { afterPreset, afterDisabled, afterPeriod: { changes: [...changes], button: text(button), detail: text(byClass(p.node, "trp-detail")[0]), window: p.window() } };
+}
+
+/* 8. The date and time boxes write the typed form and preview it. */
+{
+  const { root, button } = make();
+  fire(button, "click");
+  const [from, to] = byClass(root, "trp-pick");
+  from.value = "2026-10-01T13:00";
+  fire(from, "change");
+  const afterOne = byClass(root, "trp-text")[0].value;
+  to.value = "2026-10-01T15:00";
+  fire(to, "change");
+  found.picked = { afterOne, text: byClass(root, "trp-text")[0].value, preview: text(byClass(root, "trp-preview")[0]) };
+}
+
+/* 9. Compact hides the detail (it moves to the tooltip); the sample-interval and data-start notes appear; select() refuses what is not allowed. */
+{
+  const compact = make({ compact: true });
+  const detail = byClass(compact.p.node, "trp-detail")[0];
+  found.compact = { detail: text(detail), title: compact.p.node.attrs.title };
+  const shortOne = make({ spec: tr.relativeSpec(5 * 60000), sampleIntervalMs: 5 * 60000 });
+  const wide = make({ spec: tr.relativeSpec(4 * 3600000), sampleIntervalMs: 5 * 60000, dataStartMs: NOW - 2 * 3600000 });
+  found.notes = { short: text(byClass(shortOne.p.node, "trp-note")[0]), wide: text(byClass(wide.p.node, "trp-note")[0]) };
+  const m = make();
+  found.select = { tooLong: m.p.select(tr.relativeSpec(30 * 86400000)), tooShort: m.p.select(tr.relativeSpec(60000)), ok: m.p.select(tr.relativeSpec(3600000)), changes: m.changes.map((c) => c.id) };
+}
+
+/* 10. The reach comes from a catalog entry's max_hours when it carries one; a picker with that reach offers the long periods. */
+{
+  const entry = { name: "get_x", params: [{ name: "hours", type: "int", max_hours: 2160 }] };
+  const reach = tr.reachHours(entry);
+  const { root, button } = make({ reachHours: reach });
+  fire(button, "click");
+  found.reach = { reach, none: tr.reachHours({ name: "y", params: [] }), absent: tr.reachHours(null), items: items(root).filter((i) => i.disabled).map((i) => i.name) };
+}
+
+/* 11. A live range slides: refresh() redraws at the clock it is given. setSpec reads an id back. */
+{
+  let clock = NOW;
+  const { p, button } = make({ now: () => clock, spec: tr.relativeSpec(3600000) });
+  const first = text(byClass(p.node, "trp-detail")[0]);
+  clock = NOW + 3600000;
+  p.refresh();
+  const second = text(byClass(p.node, "trp-detail")[0]);
+  p.setSpec("previous-month");
+  found.slides = { first, second, afterSetSpec: text(button), specId: tr.specId(p.spec()) };
+}
+
+console.log(JSON.stringify(found));
diff --git a/Darling/Darling.Tests/web-kept-history-harness.mjs b/Darling/Darling.Tests/web-kept-history-harness.mjs
index 705f648917..421e4c0624 100644
--- a/Darling/Darling.Tests/web-kept-history-harness.mjs
+++ b/Darling/Darling.Tests/web-kept-history-harness.mjs
@@ -100,7 +100,7 @@ const editorScenario = scenario.startsWith("editor");
    keeps its Range presets, and the widest of them that it hands tabNote, in module-private constants, so the scratch
    copy appends one line exporting RANGE_OPTIONS and WIDEST_RANGE_HOURS, the same way the editor copy exports
    ensureFieldConfigs. */
-const serverPageScenario = scenario === "offeredRanges" || scenario.startsWith("custom");
+const serverPageScenario = scenario === "offeredRanges" || scenario.startsWith("custom") || scenario.startsWith("picker");
 const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "kept-history-"));
 let modules;
 try {
@@ -133,7 +133,7 @@ try {
   if (serverPageScenario) {
     fs.writeFileSync(
       path.join(scratch, "pages", "server.js"),
-      fs.readFileSync(path.join(jsDir, "pages", "server.js"), "utf8") + "\nexport { RANGE_OPTIONS, WIDEST_RANGE_HOURS };\n"
+      fs.readFileSync(path.join(jsDir, "pages", "server.js"), "utf8") + "\nexport { RANGE_OPTIONS, WIDEST_RANGE_HOURS, holdSpec };\n"
     );
   }
   const load = (rel) => import(pathToFileURL(path.join(scratch, rel)).href);
@@ -144,6 +144,7 @@ try {
     charts: await load("charts.js"),
     editor: editorScenario ? await load("editor.js") : null,
     server: serverPageScenario ? await load(path.join("pages", "server.js")) : null,
+    timeRange: serverPageScenario ? await load("time-range.js") : null,
   };
 } finally {
   fs.rmSync(scratch, { recursive: true, force: true });
@@ -495,6 +496,7 @@ Object.assign(scenarios, {
       rounded: r(T0, T1),
       exact: r("2026-01-02T06:30:00.000Z", T1),
       subHour: r("2026-01-02T10:00:00.000Z", T1),
+      tooShort: r("2026-01-02T10:27:00.000Z", T1),
       reversed: r(T1, T0),
       future: r("2026-05-31T00:00:00.000Z", "2026-06-02T00:00:00.000Z"),
       tooWide: r("2025-12-01T00:00:00.000Z", "2026-01-02T00:00:00.000Z"),
@@ -502,6 +504,32 @@ Object.assign(scenarios, {
     };
     return [];
   },
+  // #5562: a range under an hour is fetched as the whole hour that holds it and trimmed to the exact pair, and the picker's choices
+  // reach the page as whole-hour presets (no trimming) or as custom ranges (trimmed).
+  pickerSubHour: async () => {
+    answer = (url) => (url.pathname === "/api/fleet" ? data({ cards: [] }) : data({ samples: cpuRows }));
+    await customServerPage("SRV1");
+    const before = fetches.length;
+    const err = modules.server.holdSpec("SRV1", modules.timeRange.fixedSpec(Date.parse("2026-01-02T10:00:00.000Z"), Date.parse(T1)), NOW);
+    const ctx = modules.server.rangeContext(NOW);
+    const cpu = await modules.util.readTool("get_cpu_utilization", { server: "SRV1", hours: ctx.hours });
+    found = { err, hours: ctx.hours, label: ctx.label, custom: ctx.custom === true, reads: fetches.slice(before), rows: cpu.data.samples.length };
+    return [];
+  },
+  // Every preset and calendar period the picker offers, held for a server in the browser's zone (the scenario name carries it).
+  pickerPresetsLocal: async () => {
+    answer = (url) => (url.pathname === "/api/fleet" ? data({ cards: [] }) : data({ samples: cpuRows }));
+    await customServerPage("SRV1");
+    const tr = modules.timeRange;
+    const out = {};
+    for (const spec of [...tr.ROLLING_PRESETS, ...tr.CALENDAR_PRESETS]) {
+      const err = modules.server.holdSpec("SRV1", spec, NOW);
+      const ctx = modules.server.rangeContext(NOW);
+      out[tr.specId(spec)] = { err, hours: ctx.hours, label: ctx.label, custom: ctx.custom === true };
+    }
+    found = out;
+    return [];
+  },
   // A past-end custom range through the page: its reads carry as_of=end and the rounded hours.
   customPageReads: async () => {
     answer = (url) => (url.pathname === "/api/fleet" ? data({ cards: [] }) : data({ samples: cpuRows }));
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/css/time-range.css b/Darling/PerformanceMonitor.Darling.Service/wwwroot/css/time-range.css
new file mode 100644
index 0000000000..e20a5500c7
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/css/time-range.css
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/* The time range picker (#5562): js/time-range-picker.js. Colors come from the theme tokens only. */
+.time-range-picker { position: relative; display: inline-flex; align-items: center; gap: 0.5rem; flex-wrap: wrap; font-size: 0.78rem; color: var(--muted); }
+.trp-button {
+  background: var(--card);
+  color: var(--fg);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  padding: 0.2rem 0.55rem;
+  font-size: 0.78rem;
+  cursor: pointer;
+}
+.trp-button:hover { background: var(--lighter); }
+.trp-button:focus-visible, .trp-item:focus-visible, .trp-text:focus-visible, .trp-pick:focus-visible { outline: 2px solid var(--accent); outline-offset: 1px; }
+.trp-detail { color: var(--dim); }
+.trp-note { color: var(--warn); }
+.trp-note:empty, .trp-detail:empty { display: none; }
+.trp-popup-slot { position: absolute; top: 100%; left: 0; z-index: 30; }
+.trp-popup {
+  display: flex;
+  gap: 1rem;
+  margin-top: 0.3rem;
+  padding: 0.7rem 0.8rem;
+  background: var(--bg-dark);
+  color: var(--fg);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  box-shadow: 0 6px 18px rgba(0, 0, 0, 0.45);
+  max-width: calc(100vw - 2rem);
+  flex-wrap: wrap;
+}
+.trp-column { display: flex; flex-direction: column; gap: 0.15rem; min-width: 11rem; }
+.trp-custom { min-width: 17rem; gap: 0.4rem; }
+.trp-heading { color: var(--muted); font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.04em; margin-bottom: 0.15rem; }
+.trp-item {
+  display: flex;
+  align-items: baseline;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+  text-align: left;
+  background: transparent;
+  color: var(--fg);
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  padding: 0.2rem 0.45rem;
+  font-size: 0.78rem;
+  cursor: pointer;
+}
+.trp-item:hover { background: var(--lighter); }
+.trp-item.trp-selected { border-color: var(--accent); }
+.trp-item-name { flex: 1 1 auto; }
+.trp-item-length { color: var(--muted); }
+.trp-item-why { flex-basis: 100%; color: var(--muted); font-size: 0.7rem; }
+.trp-item.trp-disabled { color: var(--muted); cursor: not-allowed; opacity: 0.6; }
+.trp-item.trp-disabled:hover { background: transparent; }
+.trp-text, .trp-pick { background: var(--card); color: var(--fg); border: 1px solid var(--border); border-radius: var(--radius-sm); padding: 0.2rem 0.4rem; font-size: 0.78rem; }
+.trp-text { width: 100%; box-sizing: border-box; }
+.trp-preview { min-height: 2.4em; font-size: 0.74rem; color: var(--muted); }
+.trp-preview.trp-ok { color: var(--ok); }
+.trp-preview.trp-error { color: var(--err); }
+.trp-picks { display: flex; align-items: center; gap: 0.35rem; flex-wrap: wrap; }
+.trp-zone { color: var(--muted); font-size: 0.7rem; }
+.trp-apply[disabled] { opacity: 0.5; cursor: not-allowed; }
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/index.html b/Darling/PerformanceMonitor.Darling.Service/wwwroot/index.html
index b0c28e7008..24c2170e31 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/index.html
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/index.html
@@ -12,6 +12,7 @@
     <link rel="stylesheet" href="css/theme.css" />
     <link rel="stylesheet" href="css/app.css" />
     <link rel="stylesheet" href="css/editor.css" />
+    <link rel="stylesheet" href="css/time-range.css" />
   </head>
   <body>
     <div id="app">
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
index 65ffc38f56..ee56325869 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
@@ -51,21 +51,24 @@ import { databaseFilterControl, databaseFilterUnavailable } from "./database-fil
 import { setPanelSignal } from "../panels.js";
 import { serverTabsFor, isPostgresTarget, findServerTab, tabNote } from "./server-tabs.js";
 import { metricBands } from "./fleet.js";
-
-/** The page time range: the desktop viewers' presets, which stop at 7 days. All but three ranged reads on these
- *  tabs (the collection log, current waits and blocking stats) take at most McpHelpers.MaxHoursBack (168) hours, so
- *  a wider choice was never served: those panels asked again for 7 days and said so. Custom Views offer longer
- *  windows: their composed panels read the store directly, through rollups for the query tables.
+import { timeRangePicker } from "../time-range-picker.js";
+import { browserZone, resolveSpec, relativeSpec, fixedSpec, specName, wholeHours, readWindow, reachRefusal, ROLLING_PRESETS, MINIMUM_SPAN_MS } from "../time-range.js";
+
+/** How far back this page's reads reach, in hours. All but three ranged reads on these tabs (the collection log, current waits and
+ *  blocking stats) take at most McpHelpers.MaxHoursBack (168) hours, so a longer choice was never served: those panels asked again
+ *  for 7 days and said so (#2802). The picker greys out a longer range and says why. Custom Views offer longer windows: their
+ *  composed panels read the store directly, through rollups for the query tables. A catalog `max_hours` per read (#5562) lets a
+ *  page that shows one read raise this for that read; this page shows many, so it keeps the common 168.
  *  WebServerPageRangeTests runs every option through every tab of both registries. */
-const RANGE_OPTIONS = [
-  { hours: 1, label: "last hour" },
-  { hours: 4, label: "last 4 hours" },
-  { hours: 12, label: "last 12 hours" },
-  { hours: 24, label: "last 24 hours" },
-  { hours: 24 * 7, label: "last 7 days" },
-];
-
-/** The widest preset. A tab note that names the longest window this page shows (the Blocking tab's) is given it. */
+const PAGE_REACH_HOURS = 168;
+
+/** The short presets that are a whole number of hours within the reach: the ranges the reads take as `hours` alone, with no
+ *  trimming. Every other range (30 minutes, Yesterday, 2 days 3 hours, a typed pair) is fetched as whole hours back from its
+ *  end and trimmed to the exact pair, the custom path below. */
+const RANGE_OPTIONS = ROLLING_PRESETS.map((spec) => wholeHours(spec))
+  .filter((hours) => hours != null && hours <= PAGE_REACH_HOURS)
+  .map((hours) => ({ hours, label: hours === 1 ? "last hour" : hours > 24 && hours % 24 === 0 ? "last " + hours / 24 + " days" : "last " + hours + " hours" }));
+
 const WIDEST_RANGE_HOURS = Math.max(...RANGE_OPTIONS.map((o) => o.hours));
 
 /* Module state, deliberately not persisted — see the header comment. `gridNode` + the current server/tab let the
@@ -102,11 +105,11 @@ let panelAbort = null;
    matches on), module-scoped like pageHours, and bounded by the number of servers visited in one session. */
 const lastCard = new Map();
 
-/* The custom start/end, keyed by server (module scope, so the 60s poll's rebuild keeps it and another server starts on
-   the presets). Each value is `{ startMs, endMs, live, spanMs }`. A range whose end is within LIVE_SLACK_MS of now when
-   it is applied is LIVE: it keeps its width and slides to end at "now" on every rebuild, so the poll keeps refreshing
-   it. Any other end is a fixed historical window: its data cannot change, so the poll leaves the panels on screen
-   instead of reading the same hours again. */
+/* The range the reader picked that is not one of RANGE_OPTIONS, keyed by server (module scope, so the 60s poll's rebuild keeps it and
+   another server starts on the presets). Each value is `{ spec, live }`: the range as the picker names it (a length, a calendar
+   period, a typed pair) and whether its end slides with now. A LIVE range keeps its meaning and slides to end at "now" on every
+   rebuild, so the poll keeps refreshing it. Any other end is a fixed historical window: its data cannot change, so the poll leaves
+   the panels on screen instead of reading the same hours again. */
 const customRanges = new Map();
 const LIVE_SLACK_MS = 60000;
 const HOUR_MS = 3600000;
@@ -114,7 +117,8 @@ const HOUR_MS = 3600000;
 /**
  * Check a picked start and end and map them onto the reads' window (an end, `as_of`, and a whole number of `hours`).
  * The start rounds EARLIER to a whole hour for the fetch (`hours` is an integer of at least 1); the page trims what comes
- * back to the exact pair. Returns `{ error }` for an unusable pair, else `{ hours, asOf, live, startMs, endMs }`; `asOf`
+ * back to the exact pair, so a range of 15 minutes is fetched as the hour that holds it. Returns `{ error }` for an unusable
+ * pair (under 5 minutes, reversed, in the future, past the reach), else `{ hours, asOf, live, startMs, endMs }`; `asOf`
  * is null for a live range, whose reads are anchored at the server's own clock.
  */
 export function resolveCustomRange(startMs, endMs, nowMs) {
@@ -122,12 +126,28 @@ export function resolveCustomRange(startMs, endMs, nowMs) {
   if (endMs <= startMs) return { error: "The end must be after the start." };
   if (endMs > nowMs + LIVE_SLACK_MS) return { error: "The end cannot be in the future." };
   const span = endMs - startMs;
-  if (span < HOUR_MS) return { error: "Pick at least one hour. Drag across a chart to look at a shorter span." };
-  if (span > WIDEST_RANGE_HOURS * HOUR_MS) {
-    return { error: "The range can be at most " + WIDEST_RANGE_HOURS / 24 + " days, the widest preset." };
-  }
+  if (span < MINIMUM_SPAN_MS) return { error: "The shortest range is 5 minutes. Drag across a chart to look at a shorter span." };
+  const tooLong = reachRefusal(span, PAGE_REACH_HOURS);
+  if (tooLong) return { error: tooLong };
   const live = endMs >= nowMs - LIVE_SLACK_MS;
-  return { hours: Math.ceil(span / HOUR_MS), asOf: live ? null : new Date(endMs).toISOString(), live, startMs, endMs };
+  return { hours: Math.max(1, Math.ceil(span / HOUR_MS)), asOf: live ? null : new Date(endMs).toISOString(), live, startMs, endMs };
+}
+
+/** Hold a picked range for a server: a whole-hour preset is the page's own range (the reads take it as `hours` alone), anything
+ *  else is this server's custom range. Returns the error text when the range cannot be held, else null. */
+function holdSpec(server, spec, nowMs) {
+  const resolved = resolveSpec(spec, nowMs, browserZone());
+  if (!resolved.ok) return resolved.error.message;
+  const tooLong = reachRefusal(resolved.range.spanMs, PAGE_REACH_HOURS);
+  if (tooLong) return tooLong;
+  const hours = wholeHours(spec);
+  if (hours != null && RANGE_OPTIONS.some((o) => o.hours === hours)) {
+    customRanges.delete(server);
+    pageHours = hours;
+  } else {
+    customRanges.set(server, { spec, live: resolved.range.live });
+  }
+  return null;
 }
 
 /** Apply a custom range to a server and redraw. Returns the error text, or null when the range was taken. `redraw: false`
@@ -137,7 +157,8 @@ export function resolveCustomRange(startMs, endMs, nowMs) {
 export function applyCustomRange(server, startMs, endMs, nowMs = Date.now(), { redraw = true } = {}) {
   const r = resolveCustomRange(startMs, endMs, nowMs);
   if (r.error) return r.error;
-  customRanges.set(server, { startMs, endMs, live: r.live, spanMs: endMs - startMs });
+  /* A range that ends now keeps its width and slides; any other end is a fixed pair. */
+  customRanges.set(server, { spec: r.live ? relativeSpec(endMs - startMs) : fixedSpec(startMs, endMs), live: r.live });
   if (redraw) redrawPanels();
   return null;
 }
@@ -147,21 +168,23 @@ export function applyCustomRange(server, startMs, endMs, nowMs = Date.now(), { r
 export function rangeContext(nowMs = Date.now()) {
   const custom = current.server ? customRanges.get(current.server) : null;
   if (custom) {
-    const endMs = custom.live ? nowMs : custom.endMs;
-    const startMs = custom.live ? nowMs - custom.spanMs : custom.startMs;
-    const r = resolveCustomRange(startMs, endMs, nowMs);
-    if (!r.error) {
-      setActiveRange({ server: current.server, hours: r.hours, startMs, endMs, asOf: r.asOf });
+    const resolved = resolveSpec(custom.spec, nowMs, browserZone());
+    if (resolved.ok && !reachRefusal(resolved.range.spanMs, PAGE_REACH_HOURS)) {
+      const range = resolved.range;
+      const w = readWindow(range);
+      setActiveRange({ server: current.server, hours: w.hours, startMs: range.startMs, endMs: range.endMs, asOf: w.asOf });
       /* Totals and rankings are read over whole hours back from the end, so they can begin earlier than the picked start:
          when the span is not a whole number of hours the label says where they begin. */
-      const aggregateFrom = endMs - r.hours * HOUR_MS;
-      const rounded = aggregateFrom < startMs ? "; totals and rankings aggregate from " + localTime(new Date(aggregateFrom).toISOString()) : "";
-      return { hours: r.hours, label: "custom: " + localTime(new Date(startMs).toISOString()) + " to " + (custom.live ? "now" : localTime(new Date(endMs).toISOString())) + rounded, custom: true };
+      const aggregateFrom = range.endMs - w.hours * HOUR_MS;
+      const rounded = aggregateFrom < range.startMs ? "; totals and rankings aggregate from " + localTime(new Date(aggregateFrom).toISOString()) : "";
+      const times = localTime(new Date(range.startMs).toISOString()) + " to " + (range.live ? "now" : localTime(new Date(range.endMs).toISOString()));
+      const named = custom.spec.kind === "relative" || custom.spec.kind === "calendar" ? specName(custom.spec).toLowerCase() : "custom";
+      return { hours: w.hours, label: named + ": " + times + rounded, custom: true };
     }
     customRanges.delete(current.server);
   }
   setActiveRange(null);
-  const opt = RANGE_OPTIONS.find((o) => o.hours === pageHours) || RANGE_OPTIONS[3];
+  const opt = RANGE_OPTIONS.find((o) => o.hours === pageHours) || RANGE_OPTIONS.find((o) => o.hours === 24) || RANGE_OPTIONS[0];
   return { hours: opt.hours, label: opt.label };
 }
 
@@ -333,62 +356,21 @@ function subtabBar(server, active, tabs) {
   );
 }
 
-/** The time-range picker: the presets, and "Custom…" for a start and end. Changing it redraws the panels in place, exactly
- *  like the fleet page's sort. The start and end are typed in the browser's zone, the zone every time on this page uses. */
+/** The time-range picker (time-range-picker.js): the short presets, the calendar periods, a typed range and a date pick, in the
+ *  browser's zone, the zone every time on this page uses. Changing it redraws the panels in place, exactly like the fleet page's
+ *  sort. A range longer than the reads take (PAGE_REACH_HOURS) is greyed out with the reason. */
 function rangeControl() {
-  const CUSTOM = "custom";
   const server = current.server;
-  const sel = el(
-    "select",
-    { class: "range-select-inline", "aria-label": "Time range" },
-    [...RANGE_OPTIONS.map((o) => el("option", { value: String(o.hours), text: o.label })), el("option", { value: CUSTOM, text: "Custom…" })]
-  );
   const saved = customRanges.get(server);
-  sel.value = saved ? CUSTOM : String(pageHours);
-
-  const input = (label, ms) => {
-    const box = el("input", { type: "datetime-local", class: "range-custom-input", "aria-label": label, step: "60" });
-    if (ms != null) box.value = localInputValue(ms);
-    return box;
-  };
-  const start = input("Range start", saved ? saved.startMs : null);
-  const end = input("Range end", saved ? (saved.live ? Date.now() : saved.endMs) : null);
-  /* An end the form filled in as "now" stays "now" however long the form sits open: Apply then reads the clock again.
-     Typing in the end box makes it the reader's own. */
-  let endIsNow = !saved || saved.live;
-  end.addEventListener("input", () => { endIsNow = false; });
-  const message = el("span", { class: "range-custom-error", role: "alert" });
-  const apply = el("button", { type: "button", class: "btn range-custom-apply", text: "Apply" });
-  const form = el("span", { class: "range-custom" }, [start, el("span", { text: "to" }), end, apply, message]);
-  form.hidden = sel.value !== CUSTOM;
-
-  apply.addEventListener("click", () => {
-    const err = applyCustomRange(server, new Date(start.value).getTime(), endIsNow ? Date.now() : new Date(end.value).getTime());
-    message.textContent = err || "";
-  });
-  sel.addEventListener("change", () => {
-    if (sel.value === CUSTOM) {
-      form.hidden = false;
-      if (!end.value) {
-        end.value = localInputValue(Date.now());
-        endIsNow = true;
-      }
-      if (!start.value) start.value = localInputValue(Date.now() - 24 * HOUR_MS);
-      return;
-    }
-    form.hidden = true;
-    message.textContent = "";
-    customRanges.delete(server);
-    pageHours = Number(sel.value) || 24;
-    redrawPanels();
+  const picker = timeRangePicker({
+    spec: saved ? saved.spec : relativeSpec(pageHours * HOUR_MS),
+    reachHours: PAGE_REACH_HOURS,
+    label: "Time range",
+    onChange: (spec) => {
+      if (holdSpec(server, spec, Date.now()) == null) redrawPanels();
+    },
   });
-  return el("div", { class: "range-control" }, [el("span", { text: "Range" }), sel, form]);
-}
-
-/* A UTC-epoch instant as a datetime-local value in the browser's zone ("2026-01-02T03:04"). */
-function localInputValue(ms) {
-  const d = new Date(ms - new Date(ms).getTimezoneOffset() * 60000);
-  return d.toISOString().slice(0, 16);
+  return el("div", { class: "range-control" }, [el("span", { text: "Range" }), picker.node]);
 }
 
 /* This server's fleet card, plus the reason sentence the fleet's worst-first ranking computed for it. ONE
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
new file mode 100644
index 0000000000..04abcf5a98
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/*
+ * The web time range picker (#5562): a button naming the range, the resolved start, end and zone beside it, and a popup with the
+ * short presets, the calendar periods (each with its current length), a text box that shows the parsed range BEFORE Apply (or
+ * why it was refused), and a date and time pick. The grammar and every rule live in time-range.js (the twin of the desktop
+ * model, pinned by the shared fixture); this file is only the DOM.
+ *
+ *   const picker = timeRangePicker({ spec, zone, reachHours, onChange: (spec, range) => redraw() });
+ *   host.appendChild(picker.node);
+ *   picker.window();      // { hours, asOf, live, startMs, endMs } for the reads, or null when the range cannot be resolved now
+ *   picker.resolve();     // the resolved range at the current clock (a live range slides), or null
+ *   picker.setSpec(spec); // hold a range without raising onChange
+ *
+ * Keyboard: Enter in the text box applies, Esc closes the popup and returns focus to the button. Presets and periods are real
+ * buttons. A period longer than the reach (hours) or shorter than 5 minutes is disabled and says why. Nothing here touches the
+ * document until the popup opens, and the popup's own listeners are removed when it closes.
+ */
+
+import { el } from "./util.js";
+import {
+  ROLLING_PRESETS,
+  CALENDAR_PRESETS,
+  browserZone,
+  specId,
+  specName,
+  specFromId,
+  relativeSpec,
+  resolveSpec,
+  parseRange,
+  readWindow,
+  reachRefusal,
+  reachText,
+  sampleIntervalNote,
+  dataStartNote,
+  wallText,
+} from "./time-range.js";
+
+export const DEFAULT_REACH_HOURS = 168;
+
+const DAY_MS = 86400000;
+let pickerCount = 0;
+
+/**
+ * @param {object} [opts]
+ * @param {object} [opts.spec] the range to start on (default the past day)
+ * @param {string} [opts.zone] the IANA zone times are typed and shown in (default the browser's)
+ * @param {() => number} [opts.now] the clock, epoch ms (default Date.now); tests give their own
+ * @param {number} [opts.reachHours] the longest range the page's reads take, in hours (default 168); longer ones are greyed out
+ * @param {number|null} [opts.sampleIntervalMs] the main collector's interval; a span with fewer than 3 samples shows a note
+ * @param {number|null} [opts.dataStartMs] where the data begins; a range starting well before it shows a note
+ * @param {boolean} [opts.compact] hide the detail beside the button (it moves into the tooltip)
+ * @param {string} [opts.label] the accessible name (default "Time range")
+ * @param {(spec: object, range: object) => void} [opts.onChange] raised when the reader picks or applies a range
+ */
+export function timeRangePicker(opts = {}) {
+  const zone = opts.zone || browserZone();
+  const now = opts.now || (() => Date.now());
+  const name = opts.label || "Time range";
+  const previewId = "trp-preview-" + ++pickerCount;
+  let spec = opts.spec || relativeSpec(DAY_MS);
+  let reach = opts.reachHours > 0 ? opts.reachHours : DEFAULT_REACH_HOURS;
+  let sampleIntervalMs = opts.sampleIntervalMs || null;
+  let dataStartMs = opts.dataStartMs ?? null;
+  const onChange = opts.onChange || (() => {});
+  let open = false;
+  let popup = null;
+  let textBox = null;
+  let preview = null;
+  let applyButton = null;
+  let pending = null;
+  let fromBox = null;
+  let toBox = null;
+  let removeDocumentListeners = null;
+
+  const button = el("button", { type: "button", class: "trp-button", "aria-haspopup": "dialog", "aria-expanded": "false" });
+  const detail = el("span", { class: "trp-detail" });
+  const note = el("span", { class: "trp-note" });
+  const popupSlot = el("div", { class: "trp-popup-slot" });
+  const node = el("div", { class: "time-range-picker" + (opts.compact ? " trp-compact" : "") }, [button, detail, note, popupSlot]);
+
+  /* The range as it resolves right now, or the error that stops it (a calendar period under 5 minutes old, say). */
+  function current() {
+    return resolveSpec(spec, now(), zone);
+  }
+
+  function draw() {
+    const r = current();
+    if (!r.ok) {
+      button.textContent = specName(spec);
+      button.setAttribute("aria-label", name + ": " + specName(spec) + ". " + r.error.message);
+      detail.textContent = r.error.message;
+      node.setAttribute("title", r.error.message);
+      note.textContent = "";
+      return;
+    }
+    const range = r.range;
+    const text = spec.kind === "fixed" || spec.kind === "since" ? "Custom (" + range.length + ")" : specName(spec);
+    const where = range.startText + " - " + range.endText + " (" + range.zoneText + ")";
+    button.textContent = text;
+    button.setAttribute("aria-label", name + ": " + text + ", " + where);
+    detail.textContent = opts.compact ? "" : where;
+    node.setAttribute("title", opts.compact ? text + ", " + where : "");
+    const notes = [sampleIntervalNote(range.spanMs, sampleIntervalMs), dataStartNote(range, dataStartMs)].filter(Boolean);
+    note.textContent = notes.join(" ");
+  }
+
+  function hold(next) {
+    spec = next;
+    draw();
+  }
+
+  function choose(next) {
+    const r = resolveSpec(next, now(), zone);
+    if (!r.ok) return r.error.message;
+    const tooLong = reachRefusal(r.range.spanMs, reach);
+    if (tooLong) return tooLong;
+    hold(next);
+    close(true);
+    onChange(next, r.range);
+    return null;
+  }
+
+  /* One row of the popup lists: the name, the length it is right now, and why it is greyed out when it is. */
+  function item(next, nowMs) {
+    const r = resolveSpec(next, nowMs, zone);
+    const why = !r.ok ? r.error.message : reachRefusal(r.range.spanMs, reach);
+    const selected = specId(next) === specId(spec);
+    const children = [el("span", { class: "trp-item-name", text: specName(next) })];
+    if (r.ok) children.push(el("span", { class: "trp-item-length", text: r.range.length }));
+    if (why) children.push(el("span", { class: "trp-item-why", text: why }));
+    const props = { type: "button", class: "trp-item" + (selected ? " trp-selected" : "") + (why ? " trp-disabled" : ""), "aria-pressed": selected ? "true" : "false" };
+    if (why) {
+      props["aria-disabled"] = "true";
+      props.title = why;
+    }
+    const b = el("button", props, children);
+    b.addEventListener("click", () => {
+      if (why) return;
+      choose(next);
+    });
+    return b;
+  }
+
+  /* Shows what the text box means, or why it does not mean anything, before Apply. */
+  function showPreview() {
+    pending = null;
+    const text = textBox.value;
+    if (text.trim() === "") {
+      preview.textContent = "Type a range, or pick one on the left.";
+      preview.className = "trp-preview";
+      applyButton.disabled = true;
+      return;
+    }
+    const nowMs = now();
+    const r = parseRange(text, nowMs, zone);
+    let error = r.ok ? null : r.error;
+    if (r.ok) {
+      const tooLong = reachRefusal(r.range.spanMs, reach);
+      if (tooLong) error = tooLong;
+    }
+    if (error) {
+      preview.textContent = error;
+      preview.className = "trp-preview trp-error";
+      applyButton.disabled = true;
+      return;
+    }
+    pending = r;
+    const notes = [sampleIntervalNote(r.range.spanMs, sampleIntervalMs), dataStartNote(r.range, dataStartMs)].filter(Boolean);
+    preview.textContent = [r.echo, ...notes].join(" ");
+    preview.className = "trp-preview trp-ok";
+    applyButton.disabled = false;
+  }
+
+  function apply() {
+    if (!pending) {
+      showPreview();
+      if (!pending) return;
+    }
+    choose(pending.spec);
+  }
+
+  /* The date and time boxes write the typed form (in the picker's zone), so one path parses, previews and applies. */
+  function pickChanged() {
+    if (!fromBox.value || !toBox.value) return;
+    textBox.value = fromBox.value.replace("T", " ") + " - " + toBox.value.replace("T", " ");
+    showPreview();
+  }
+
+  function buildPopup() {
+    const nowMs = now();
+    const r = current();
+    textBox = el("input", { type: "text", class: "trp-text", "aria-label": "Type a time range", "aria-describedby": previewId, placeholder: "45m, last month, Oct 1 - Oct 2", autocomplete: "off", spellcheck: "false" });
+    preview = el("div", { class: "trp-preview", id: previewId, role: "status", "aria-live": "polite" });
+    applyButton = el("button", { type: "button", class: "btn trp-apply", text: "Apply" });
+    fromBox = el("input", { type: "datetime-local", class: "trp-pick", "aria-label": "Range start", step: "60" });
+    toBox = el("input", { type: "datetime-local", class: "trp-pick", "aria-label": "Range end", step: "60" });
+    if (r.ok) {
+      fromBox.value = wallText(r.range.startMs, zone).replace(" ", "T").slice(0, 16);
+      toBox.value = wallText(r.range.endMs, zone).replace(" ", "T").slice(0, 16);
+    }
+    textBox.addEventListener("input", showPreview);
+    textBox.addEventListener("keydown", (e) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        apply();
+      }
+    });
+    applyButton.addEventListener("click", apply);
+    fromBox.addEventListener("change", pickChanged);
+    toBox.addEventListener("change", pickChanged);
+
+    const quick = el("div", { class: "trp-column" }, [
+      el("div", { class: "trp-heading", text: "Quick ranges" }),
+      ...ROLLING_PRESETS.map((s) => item(s, nowMs)),
+    ]);
+    const periods = el("div", { class: "trp-column" }, [
+      el("div", { class: "trp-heading", text: "Calendar periods" }),
+      ...CALENDAR_PRESETS.map((s) => item(s, nowMs)),
+    ]);
+    const custom = el("div", { class: "trp-column trp-custom" }, [
+      el("div", { class: "trp-heading", text: "Type a range" }),
+      textBox,
+      preview,
+      el("div", { class: "trp-heading", text: "Or pick a start and an end" }),
+      el("div", { class: "trp-picks" }, [fromBox, el("span", { text: "to" }), toBox]),
+      el("div", { class: "trp-zone", text: "Times are in " + zone.replace(/_/g, " ") + "." }),
+      applyButton,
+    ]);
+    popup = el("div", { class: "trp-popup", role: "dialog", "aria-label": name + " options" }, [quick, periods, custom]);
+    popup.addEventListener("keydown", (e) => {
+      if (e.key === "Escape") {
+        e.stopPropagation();
+        close(true);
+      }
+    });
+    showPreview();
+  }
+
+  function openPopup() {
+    if (open) return;
+    open = true;
+    buildPopup();
+    popupSlot.appendChild(popup);
+    button.setAttribute("aria-expanded", "true");
+    /* A click anywhere else closes the popup. The listener exists only while the popup is open. */
+    const outside = (e) => {
+      if (!node.contains || !node.contains(e.target)) close(false);
+    };
+    document.addEventListener("mousedown", outside);
+    removeDocumentListeners = () => document.removeEventListener("mousedown", outside);
+    if (textBox.focus) textBox.focus();
+  }
+
+  function close(refocus) {
+    if (!open) return;
+    open = false;
+    if (removeDocumentListeners) removeDocumentListeners();
+    removeDocumentListeners = null;
+    if (popup) popupSlot.removeChild(popup);
+    popup = null;
+    button.setAttribute("aria-expanded", "false");
+    if (refocus && button.focus) button.focus();
+  }
+
+  button.addEventListener("click", () => (open ? close(true) : openPopup()));
+  button.addEventListener("keydown", (e) => {
+    if (e.key === "Escape") close(true);
+  });
+  draw();
+
+  return {
+    node,
+    /** The range as it resolves now, or null when it cannot be (a live range slides with the clock). */
+    resolve() {
+      const r = current();
+      return r.ok ? r.range : null;
+    },
+    /** The window the reads take for the range now ({ hours, asOf, live, startMs, endMs }), or null. */
+    window() {
+      const r = current();
+      return r.ok ? readWindow(r.range) : null;
+    },
+    spec() {
+      return spec;
+    },
+    /** Hold a range without raising onChange (a stored choice, a deep link). A spec the grammar can read back by id works too. */
+    setSpec(next) {
+      const s = typeof next === "string" ? specFromId(next) : next;
+      if (s) hold(s);
+    },
+    /** Pick a range as if the reader had: holds it, closes the popup and raises onChange. Returns the refusal, or null. */
+    select(next) {
+      return choose(next);
+    },
+    /** Redraw the label and detail (a live range slides; call on a refresh tick). */
+    refresh: draw,
+    setReach(hours) {
+      reach = hours > 0 ? hours : DEFAULT_REACH_HOURS;
+      if (open) {
+        close(false);
+        openPopup();
+      }
+    },
+    setSampleInterval(ms) {
+      sampleIntervalMs = ms || null;
+      draw();
+    },
+    setDataStart(ms) {
+      dataStartMs = ms ?? null;
+      draw();
+    },
+    openPopup,
+    close: () => close(true),
+    isOpen: () => open,
+    /** The longest range the page takes, in words ("7 days"). */
+    reachText: () => reachText(reach),
+  };
+}
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
new file mode 100644
index 0000000000..19ac647cc2
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
@@ -0,0 +1,873 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/*
+ * The time range grammar for the web (#5562): one line of text, a preset or a calendar period becomes a start and an end.
+ * This is the twin of PerformanceMonitor.Ui/TimeRange (TimeRangeParser, TimeRangeSpec, ResolvedTimeRange, TimeRangePresets):
+ * the same grammar, the same resolution rules and the same label text, pinned by the shared cases in
+ * Darling.Tests/Fixtures/time-range-cases.json, which both implementations run.
+ *
+ * PURE: no DOM, no clock, no imports. Every function is given the now (epoch milliseconds) and the zone (an IANA name such as
+ * "America/New_York"; the page passes the browser's zone, browserZone()). All wall-clock work goes through Intl with an
+ * explicit timeZone, so the module never depends on the process zone and a test can drive any zone.
+ *
+ * Rules (settled, #5562): relative lengths (45m, 4h, 10d, 1mo = 30 days) are real elapsed time; calendar periods use the zone's
+ * wall-clock midnights, weeks start Monday, and a boundary is the earliest instant labelled at or after the wall midnight
+ * so neighbouring periods tile; typed wall times take the widest instants they can mean (a start the earliest, an end the
+ * latest; a repeated hour widens, a skipped time maps to the change instant); nothing shorter than 5 minutes is accepted
+ * and nothing is widened; there is no upper cap here (a page decides what its reads reach).
+ *
+ * A spec is a plain object: { kind: "relative", spanMs }, { kind: "calendar", period }, { kind: "fixed", startMs, endMs } or
+ * { kind: "since", startMs }. resolveSpec turns it into a range for a now and a zone; parseRange turns text into one.
+ */
+
+const MINUTE_MS = 60000;
+const HOUR_MS = 3600000;
+const DAY_MS = 86400000;
+
+/** The shortest range there is. A shorter one is refused, never widened. */
+export const MINIMUM_SPAN_MS = 5 * MINUTE_MS;
+
+/** A tab note appears when the span holds fewer than this many samples. */
+export const MIN_SAMPLES = 3;
+
+/** The data-start note appears when the range starts more than this long before the data does. */
+export const DATA_START_SLACK_MS = 90 * MINUTE_MS;
+
+const MAX_RELATIVE_MS = 36500 * DAY_MS;
+const LAST_DAY_MS = Date.UTC(9999, 11, 31, 23, 59, 59, 999);
+const EXAMPLES = "Try 45m, 3 days, last month, Oct 1 - Oct 2 or 1:00 am - 7:00 am.";
+
+/* ───────────────────────────────── zone arithmetic (Intl, explicit zone) ───────────────────────────────── */
+
+const formatters = new Map();
+
+function formatterFor(zone) {
+  let f = formatters.get(zone);
+  if (!f) {
+    f = new Intl.DateTimeFormat("en-US", {
+      timeZone: zone,
+      hourCycle: "h23",
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+    });
+    formatters.set(zone, f);
+  }
+  return f;
+}
+
+/** The browser's zone as an IANA name ("UTC" when the browser will not say). */
+export function browserZone() {
+  try {
+    return new Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+    return "UTC";
+  }
+}
+
+/** True when Intl knows the zone name. */
+export function isKnownZone(zone) {
+  try {
+    formatterFor(zone);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The wall clock of an instant in a zone, as "wall ms": the same fields read as if they were UTC. Exact in a repeated hour. */
+export function toWall(ms, zone) {
+  const base = Math.floor(ms / 1000) * 1000;
+  const p = {};
+  for (const part of formatterFor(zone).formatToParts(new Date(base))) p[part.type] = Number(part.value);
+  return Date.UTC(p.year, p.month - 1, p.day, p.hour % 24, p.minute, p.second) + (ms - base);
+}
+
+/** The zone's UTC offset at an instant, in milliseconds (east of UTC is positive). */
+export function offsetAt(ms, zone) {
+  return toWall(ms, zone) - ms;
+}
+
+/** "+hh:mm" or "-hh:mm" ("+00:00" in UTC). */
+export function formatOffset(offsetMs) {
+  const sign = offsetMs < 0 ? "-" : "+";
+  const totalMinutes = Math.round(Math.abs(offsetMs) / MINUTE_MS);
+  return sign + pad2(Math.floor(totalMinutes / 60)) + ":" + pad2(totalMinutes % 60);
+}
+
+/** The instants whose wall clock reads `wallMs`: none (a clock change skipped it), one, or two (it happened twice), earliest first. */
+function instantsOfWall(wallMs, zone) {
+  const found = [];
+  for (const o of new Set([offsetAt(wallMs - DAY_MS, zone), offsetAt(wallMs + DAY_MS, zone)])) {
+    const u = wallMs - o;
+    if (offsetAt(u, zone) === o) found.push(u);
+  }
+  return found.sort((a, b) => a - b);
+}
+
+/** The instant a clock change skips a wall time over: the first instant on the far side of the gap, found by halving the day either side. */
+function skippedChangeInstant(wallMs, zone) {
+  let lo = wallMs - DAY_MS;
+  let hi = wallMs + DAY_MS;
+  const before = offsetAt(lo, zone);
+  while (hi - lo > 1) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (offsetAt(mid, zone) === before) lo = mid;
+    else hi = mid;
+  }
+  return hi;
+}
+
+/**
+ * The instant a typed wall-clock bound means, as the widest range it can name: side "from" is the earliest instant whose wall
+ * clock reads at or after the value, "to" the latest at or before it. A time that happens once is that instant; in the repeated
+ * hour from takes the first occurrence and to the second; a time that never happened gives the change instant for both.
+ */
+export function wallToUtcBound(wallMs, zone, side) {
+  const found = instantsOfWall(wallMs, zone);
+  if (found.length === 0) return skippedChangeInstant(wallMs, zone);
+  if (found.length === 1) return found[0];
+  return side === "from" ? found[0] : found[found.length - 1];
+}
+
+/** " +hh:mm"-style offset of an instant whose wall time happens twice, else null. */
+function ambiguousOffsetSuffix(ms, zone) {
+  return instantsOfWall(toWall(ms, zone), zone).length === 2 ? formatOffset(offsetAt(ms, zone)) : null;
+}
+
+/* ───────────────────────────────── small helpers ───────────────────────────────── */
+
+function pad2(n) {
+  return n < 10 ? "0" + n : String(n);
+}
+
+const MONTH_ABBR = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+function daysInMonth(year, month) {
+  return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+
+/** Round half to even, the way Math.Round does in the C# twin. */
+function roundEven(x) {
+  const f = Math.floor(x);
+  const d = x - f;
+  if (d < 0.5) return f;
+  if (d > 0.5) return f + 1;
+  return f % 2 === 0 ? f : f + 1;
+}
+
+function floorDay(wallMs) {
+  return Math.floor(wallMs / DAY_MS) * DAY_MS;
+}
+
+/** "2026-10-01T04:00:00Z": whole seconds, the form a spec id carries. */
+export function isoZ(ms) {
+  return new Date(Math.floor(ms / 1000) * 1000).toISOString().replace(".000Z", "Z");
+}
+
+/** The length of a span as the picker words it: "3d" for three days and some hours, "7h 1m" under a day, "45m". Floors. */
+export function formatLength(spanMs) {
+  const totalMinutes = Math.floor(Math.max(0, spanMs) / MINUTE_MS);
+  if (totalMinutes >= 1440) return Math.floor(totalMinutes / 1440) + "d";
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours === 0) return minutes + "m";
+  return minutes === 0 ? hours + "h" : hours + "h " + minutes + "m";
+}
+
+function shortMessage(actualMs) {
+  return actualMs <= 0
+    ? "The shortest range is 5 minutes."
+    : "That range is only " + formatLength(actualMs) + " long. The shortest range is 5 minutes.";
+}
+
+/* ───────────────────────────────── specs ───────────────────────────────── */
+
+/** A length counted back from now. */
+export function relativeSpec(spanMs) {
+  return { kind: "relative", spanMs };
+}
+
+/** A calendar period in the zone: today, yesterday, week-to-date, previous-week, month-to-date, previous-month, year-to-date, previous-year. */
+export function calendarSpec(period) {
+  return { kind: "calendar", period };
+}
+
+/** A start and an end instant. */
+export function fixedSpec(startMs, endMs) {
+  return { kind: "fixed", startMs, endMs };
+}
+
+/** A fixed start with an end that is always now. */
+export function sinceSpec(startMs) {
+  return { kind: "since", startMs };
+}
+
+const PERIOD_IDS = ["today", "yesterday", "week-to-date", "previous-week", "month-to-date", "previous-month", "year-to-date", "previous-year"];
+
+const PERIOD_NAMES = {
+  today: "Today",
+  yesterday: "Yesterday",
+  "week-to-date": "Week to Date",
+  "previous-week": "Previous Week",
+  "month-to-date": "Month to Date",
+  "previous-month": "Previous Month",
+  "year-to-date": "Year to Date",
+  "previous-year": "Previous Year",
+};
+
+/** The nine short presets, in the order the picker lists them. */
+export const ROLLING_PRESETS = [
+  relativeSpec(5 * MINUTE_MS),
+  relativeSpec(15 * MINUTE_MS),
+  relativeSpec(30 * MINUTE_MS),
+  relativeSpec(HOUR_MS),
+  relativeSpec(4 * HOUR_MS),
+  relativeSpec(DAY_MS),
+  relativeSpec(2 * DAY_MS),
+  relativeSpec(7 * DAY_MS),
+  relativeSpec(30 * DAY_MS),
+];
+
+/** The eight calendar periods, in the order the picker lists them. */
+export const CALENDAR_PRESETS = PERIOD_IDS.map(calendarSpec);
+
+/** A stable text for a spec: "5m", "4h", "1d", "1w", "1mo", "today", "previous-week", "fixed:<start>/<end>", "since:<start>". */
+export function specId(spec) {
+  switch (spec.kind) {
+    case "relative": {
+      const s = spec.spanMs;
+      if (s === 7 * DAY_MS) return "1w";
+      if (s === 30 * DAY_MS) return "1mo";
+      if (s % DAY_MS === 0) return s / DAY_MS + "d";
+      if (s % HOUR_MS === 0) return s / HOUR_MS + "h";
+      return roundEven(s / MINUTE_MS) + "m";
+    }
+    case "calendar":
+      return spec.period;
+    case "fixed":
+      return "fixed:" + isoZ(spec.startMs) + "/" + isoZ(spec.endMs);
+    default:
+      return "since:" + isoZ(spec.startMs);
+  }
+}
+
+const ISO_Z_RX = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/;
+
+function parseIsoZ(text) {
+  const m = ISO_Z_RX.exec(String(text).toUpperCase());
+  return m ? Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]) : null;
+}
+
+/** Reads an id back: a preset id, a count and unit ("90m", "3d", "2w", "2mo"), "fixed:..." or "since:...". Null for anything else. */
+export function specFromId(id) {
+  if (typeof id !== "string" || id.trim() === "") return null;
+  const text = id.trim().toLowerCase();
+  if (PERIOD_IDS.includes(text)) return calendarSpec(text);
+  if (text.startsWith("since:")) {
+    const at = parseIsoZ(text.slice(6));
+    return at == null ? null : sinceSpec(at);
+  }
+  if (text.startsWith("fixed:")) {
+    const parts = text.slice(6).split("/");
+    const a = parts.length === 2 ? parseIsoZ(parts[0]) : null;
+    const b = parts.length === 2 ? parseIsoZ(parts[1]) : null;
+    return a == null || b == null ? null : fixedSpec(a, b);
+  }
+  const m = /^(\d+)([a-z]+)$/.exec(text);
+  if (!m) return null;
+  const count = Number(m[1]);
+  if (!(count > 0) || count > 1000000) return null;
+  switch (m[2]) {
+    case "m": return relativeSpec(count * MINUTE_MS);
+    case "h": return relativeSpec(count * HOUR_MS);
+    case "d": return relativeSpec(count * DAY_MS);
+    case "w": return relativeSpec(7 * count * DAY_MS);
+    case "mo": return relativeSpec(30 * count * DAY_MS);
+    default: return null;
+  }
+}
+
+/** The spec for a count of whole hours (the legacy `hours` the reads and old settings carry), or null. */
+export function fromLegacyHours(hours) {
+  return Number.isFinite(hours) && hours > 0 ? relativeSpec(hours * HOUR_MS) : null;
+}
+
+/** The whole hours of a relative spec, or null when it is not a whole number of hours (or not relative). */
+export function wholeHours(spec) {
+  return spec.kind === "relative" && spec.spanMs % HOUR_MS === 0 ? spec.spanMs / HOUR_MS : null;
+}
+
+function pastLength(spanMs) {
+  if (spanMs === 7 * DAY_MS) return "week";
+  if (spanMs === 30 * DAY_MS) return "30 days";
+  let count;
+  let unit;
+  if (spanMs % DAY_MS === 0) {
+    count = spanMs / DAY_MS;
+    unit = "day";
+  } else if (spanMs % HOUR_MS === 0) {
+    count = spanMs / HOUR_MS;
+    unit = "hour";
+  } else {
+    count = roundEven(spanMs / MINUTE_MS);
+    unit = "minute";
+  }
+  return count === 1 ? unit : count + " " + unit + "s";
+}
+
+/** The name the picker lists: "Past 4 hours", "Previous Week"; a fixed or since range reads as a generic name. */
+export function specName(spec) {
+  switch (spec.kind) {
+    case "relative": return "Past " + pastLength(spec.spanMs);
+    case "calendar": return PERIOD_NAMES[spec.period];
+    case "fixed": return "Custom range";
+    default: return "Since a start";
+  }
+}
+
+/* ───────────────────────────────── resolution ───────────────────────────────── */
+
+function resolvePeriod(period, nowMs, zone) {
+  const wallNow = new Date(toWall(nowMs, zone));
+  const today = Date.UTC(wallNow.getUTCFullYear(), wallNow.getUTCMonth(), wallNow.getUTCDate());
+  const monday = today - ((new Date(today).getUTCDay() + 6) % 7) * DAY_MS;
+  const y = wallNow.getUTCFullYear();
+  const firstOfMonth = Date.UTC(y, wallNow.getUTCMonth(), 1);
+  const firstOfYear = Date.UTC(y, 0, 1);
+  const b = (wall) => wallToUtcBound(wall, zone, "from");
+  switch (period) {
+    case "today": return { start: b(today), end: nowMs, live: true };
+    case "yesterday": return { start: b(today - DAY_MS), end: b(today), live: false };
+    case "week-to-date": return { start: b(monday), end: nowMs, live: true };
+    case "previous-week": return { start: b(monday - 7 * DAY_MS), end: b(monday), live: false };
+    case "month-to-date": return { start: b(firstOfMonth), end: nowMs, live: true };
+    case "previous-month": return { start: b(Date.UTC(y, wallNow.getUTCMonth() - 1, 1)), end: b(firstOfMonth), live: false };
+    case "year-to-date": return { start: b(firstOfYear), end: nowMs, live: true };
+    default: return { start: b(Date.UTC(y - 1, 0, 1)), end: b(firstOfYear), live: false };
+  }
+}
+
+function formatBound(ms, ctx, includeSeconds) {
+  const wall = new Date(toWall(ms, ctx.zone));
+  const hour12 = wall.getUTCHours() % 12 === 0 ? 12 : wall.getUTCHours() % 12;
+  let clock = hour12 + ":" + pad2(wall.getUTCMinutes());
+  if (includeSeconds && wall.getUTCSeconds() !== 0) clock += ":" + pad2(wall.getUTCSeconds());
+  const day = MONTH_ABBR[wall.getUTCMonth()] + " " + wall.getUTCDate() + (ctx.showYear ? ", " + wall.getUTCFullYear() : "");
+  const text = day + ", " + clock + (wall.getUTCHours() < 12 ? " am" : " pm");
+  const suffix = ambiguousOffsetSuffix(ms, ctx.zone);
+  return suffix == null ? text : text + " " + suffix;
+}
+
+function wallYear(ms, zone) {
+  return new Date(toWall(ms, zone)).getUTCFullYear();
+}
+
+function buildRange(spec, startMs, endMs, live, zone, nowMs) {
+  const nowYear = wallYear(nowMs, zone);
+  const ctx = { zone, showYear: wallYear(startMs, zone) !== nowYear || wallYear(endMs, zone) !== nowYear };
+  const seconds = spec.kind === "fixed";
+  const a = "UTC" + formatOffset(offsetAt(startMs, zone));
+  const b = "UTC" + formatOffset(offsetAt(endMs, zone));
+  const zoneText = a === b ? a : a + " to " + b;
+  const length = formatLength(endMs - startMs);
+  const startText = formatBound(startMs, ctx, seconds);
+  const endText = formatBound(endMs, ctx, seconds);
+  return {
+    spec,
+    id: specId(spec),
+    startMs,
+    endMs,
+    live,
+    zone,
+    nowMs,
+    spanMs: endMs - startMs,
+    length,
+    startText,
+    endText,
+    zoneText,
+    label: length + "  " + startText + " - " + endText + " (" + zoneText + ")",
+  };
+}
+
+/**
+ * The instants a spec means at `nowMs` in `zone`: `{ ok: true, range }` or `{ ok: false, error: { code, message } }` (shorter than
+ * 5 minutes, ends before it starts, reaches back too far). The range carries startMs, endMs, live (the end slides with now),
+ * spanMs, length, startText, endText, zoneText and label ("3d  Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)").
+ */
+export function resolveSpec(spec, nowMs, zone) {
+  const fail = (code, message) => ({ ok: false, error: { code, message } });
+  let start;
+  let end;
+  let live;
+  switch (spec.kind) {
+    case "relative":
+      if (!(spec.spanMs > 0)) return fail("too_short", shortMessage(0));
+      if (spec.spanMs > MAX_RELATIVE_MS) return fail("too_far_back", "That reaches back more than 100 years.");
+      start = nowMs - spec.spanMs;
+      end = nowMs;
+      live = true;
+      break;
+    case "calendar":
+      ({ start, end, live } = resolvePeriod(spec.period, nowMs, zone));
+      break;
+    case "since":
+      start = spec.startMs;
+      end = nowMs;
+      live = true;
+      break;
+    default:
+      start = spec.startMs;
+      end = spec.endMs;
+      live = false;
+      break;
+  }
+  if (end < start) {
+    return spec.kind === "since"
+      ? fail("start_in_future", "That start has not happened yet.")
+      : fail("end_before_start", "The end is before the start.");
+  }
+  if (end - start < MINIMUM_SPAN_MS) return fail("too_short", shortMessage(end - start));
+  return { ok: true, range: buildRange(spec, start, end, live, zone, nowMs) };
+}
+
+/** The current length of a spec ("7h 1m" for Today), or null when it cannot be used right now (a calendar period under 5 minutes). */
+export function currentLength(spec, nowMs, zone) {
+  const r = resolveSpec(spec, nowMs, zone);
+  return r.ok ? r.range.length : null;
+}
+
+/* ───────────────────────────────── the typed-range parser ───────────────────────────────── */
+
+class ParseFailure extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+
+const RELATIVE_RX = /^(?:(?:last|past|previous)\s+)?(\d+(?:\.\d+)?)\s*([a-z]+)$/;
+const SEPARATOR_RX = /\s+(?:-|to|until)\s+/;
+const UNIX_RX = /^(?:\d{10}|\d{13})$/;
+const ISO_T_RX = /(\d{4}-\d{1,2}-\d{1,2})t(\d)/g;
+const TIME12_RX = /(?:^|\s)(\d{1,2})(?::(\d{2}))?(?::(\d{2}))?\s*(am|pm)$/;
+const TIME24_RX = /(?:^|\s)(\d{1,2}):(\d{2})(?::(\d{2}))?$/;
+const TIME_WORD_RX = /(?:^|\s)(noon|midnight)$/;
+const MONTH_DAY_RX = /^([a-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?(?:\s+(\d{4}))?$/;
+const DAY_MONTH_RX = /^(\d{1,2})(?:st|nd|rd|th)?\s+([a-z]+)(?:\s+(\d{4}))?$/;
+const SLASH_RX = /^(\d{1,2})\/(\d{1,2})(?:\/(\d{4}|\d{2}))?$/;
+const ISO_RX = /^(\d{4})-(\d{1,2})-(\d{1,2})$/;
+
+const PERIODS = new Map([
+  ["today", "today"],
+  ["yesterday", "yesterday"],
+  ["this week", "week-to-date"],
+  ["week to date", "week-to-date"],
+  ["wtd", "week-to-date"],
+  ["last week", "previous-week"],
+  ["previous week", "previous-week"],
+  ["this month", "month-to-date"],
+  ["month to date", "month-to-date"],
+  ["mtd", "month-to-date"],
+  ["last month", "previous-month"],
+  ["previous month", "previous-month"],
+  ["this year", "year-to-date"],
+  ["year to date", "year-to-date"],
+  ["ytd", "year-to-date"],
+  ["last year", "previous-year"],
+  ["previous year", "previous-year"],
+]);
+
+const MONTHS = new Map([
+  ["jan", 1], ["january", 1], ["feb", 2], ["february", 2], ["mar", 3], ["march", 3],
+  ["apr", 4], ["april", 4], ["may", 5], ["jun", 6], ["june", 6], ["jul", 7], ["july", 7],
+  ["aug", 8], ["august", 8], ["sep", 9], ["sept", 9], ["september", 9],
+  ["oct", 10], ["october", 10], ["nov", 11], ["november", 11], ["dec", 12], ["december", 12],
+]);
+
+const UNITS = new Map([
+  ["m", 60], ["min", 60], ["mins", 60], ["minute", 60], ["minutes", 60],
+  ["h", 3600], ["hr", 3600], ["hrs", 3600], ["hour", 3600], ["hours", 3600],
+  ["d", 86400], ["day", 86400], ["days", 86400],
+  ["w", 604800], ["wk", 604800], ["wks", 604800], ["week", 604800], ["weeks", 604800],
+  ["mo", 2592000], ["month", 2592000], ["months", 2592000],
+]);
+
+function normalize(text) {
+  if (text == null || String(text).trim() === "") return "";
+  return String(text).trim().toLowerCase().replace(/[–—−]/g, "-").replace(/,/g, " ").replace(/\s+/g, " ").trim();
+}
+
+/** One side of a typed range, before it has a year, a day or a zone. Times are milliseconds into the day, or null. */
+function newPoint() {
+  return { isNow: false, instantMs: null, hasDate: false, year: null, month: 0, day: 0, timeMs: null };
+}
+
+function withYear(p, year) {
+  if (year < 1 || year > 9999 || p.day > daysInMonth(year, p.month)) throw new ParseFailure("bad_date", "That date does not exist.");
+  return Date.UTC(year, p.month - 1, p.day);
+}
+
+/** The calendar day of a point that has a date. Without a year it is the latest such day-and-time not after now. */
+function dateFor(p, wallNow, timeMs) {
+  if (p.year != null) return withYear(p, p.year);
+  const nowYear = new Date(wallNow).getUTCFullYear();
+  for (let year = nowYear; year >= nowYear - 8; year--) {
+    if (p.day <= daysInMonth(year, p.month)) {
+      const candidate = Date.UTC(year, p.month - 1, p.day);
+      if (candidate + (timeMs ?? 0) <= wallNow) return candidate;
+    }
+  }
+  throw new ParseFailure("bad_date", "That date does not exist.");
+}
+
+/** An end typed without a year that falls before its start means the next year, but only when that end has already happened. */
+function rollEndIntoNextYear(end, startDate, endDate, wallNow) {
+  const startYear = new Date(startDate).getUTCFullYear();
+  if (endDate >= startDate || startYear >= 9999) return endDate;
+  try {
+    const next = withYear(end, startYear + 1);
+    return next <= wallNow ? next : endDate;
+  } catch (e) {
+    if (e instanceof ParseFailure) return endDate;
+    throw e;
+  }
+}
+
+function splitSides(s) {
+  let parts = s.split(SEPARATOR_RX);
+  if (parts.length === 1) {
+    const dashes = s.split("-");
+    if (dashes.length === 2) parts = dashes;
+  }
+  if (parts.length > 2) throw new ParseFailure("bad_range", "Use one start and one end. " + EXAMPLES);
+  return parts.map((part) => {
+    const side = part.trim();
+    if (side.length === 0) throw new ParseFailure("unrecognized", "A range needs something on both sides of the dash. " + EXAMPLES);
+    return side;
+  });
+}
+
+function parseDate(d, point, wallNow, original) {
+  point.hasDate = true;
+  if (d === "today" || d === "yesterday") {
+    const day = new Date(floorDay(wallNow) - (d === "today" ? 0 : DAY_MS));
+    point.year = day.getUTCFullYear();
+    point.month = day.getUTCMonth() + 1;
+    point.day = day.getUTCDate();
+    return;
+  }
+
+  let month;
+  let dayOfMonth;
+  let yearText = "";
+  const md = MONTH_DAY_RX.exec(d);
+  const dm = DAY_MONTH_RX.exec(d);
+  const slash = SLASH_RX.exec(d);
+  const iso = ISO_RX.exec(d);
+  if (md && MONTHS.has(md[1])) {
+    month = MONTHS.get(md[1]);
+    dayOfMonth = Number(md[2]);
+    yearText = md[3] ?? "";
+  } else if (dm && MONTHS.has(dm[2])) {
+    month = MONTHS.get(dm[2]);
+    dayOfMonth = Number(dm[1]);
+    yearText = dm[3] ?? "";
+  } else if (slash) {
+    month = Number(slash[1]);
+    dayOfMonth = Number(slash[2]);
+    yearText = slash[3] ?? "";
+    if (yearText.length === 2) yearText = "20" + yearText;
+  } else if (iso) {
+    yearText = iso[1];
+    month = Number(iso[2]);
+    dayOfMonth = Number(iso[3]);
+  } else {
+    throw new ParseFailure("unrecognized", "\"" + original.trim() + "\" is not a date or a time. " + EXAMPLES);
+  }
+
+  if (month < 1 || month > 12 || dayOfMonth < 1 || dayOfMonth > 31) {
+    throw new ParseFailure("bad_date", "\"" + original.trim() + "\" is not a date that exists.");
+  }
+  if (yearText.length > 0) {
+    const year = Number(yearText);
+    if (year < 1900 || year > 9999 || dayOfMonth > daysInMonth(year, month)) {
+      throw new ParseFailure("bad_date", "\"" + original.trim() + "\" is not a date that exists.");
+    }
+    point.year = year;
+  } else if (dayOfMonth > daysInMonth(2024, month)) {
+    throw new ParseFailure("bad_date", "\"" + original.trim() + "\" is not a date that exists.");
+  }
+  point.month = month;
+  point.day = dayOfMonth;
+}
+
+function parsePoint(text, wallNow) {
+  let p = text.trim();
+  if (p === "now") {
+    const now = newPoint();
+    now.isNow = true;
+    return now;
+  }
+  if (UNIX_RX.test(p)) {
+    const number = Number(p);
+    const unix = newPoint();
+    unix.instantMs = p.length === 13 ? number : number * 1000;
+    return unix;
+  }
+
+  p = p.replace(ISO_T_RX, "$1 $2");
+  if (p.startsWith("at ")) p = p.slice(3);
+  else if (p.startsWith("on ")) p = p.slice(3);
+  p = p.replaceAll(" at ", " ");
+
+  const point = newPoint();
+  let datePart = p;
+  const m12 = TIME12_RX.exec(p);
+  const m24 = TIME24_RX.exec(p);
+  const mWord = TIME_WORD_RX.exec(p);
+  if (m12) {
+    const hour = Number(m12[1]);
+    const minute = m12[2] != null ? Number(m12[2]) : 0;
+    const second = m12[3] != null ? Number(m12[3]) : 0;
+    if (hour < 1 || hour > 12 || minute > 59 || second > 59) {
+      throw new ParseFailure("bad_time", "\"" + m12[0].trim() + "\" is not a time on a 12-hour clock.");
+    }
+    const pm = m12[4] === "pm";
+    point.timeMs = (((hour % 12) + (pm ? 12 : 0)) * 3600 + minute * 60 + second) * 1000;
+    datePart = p.slice(0, m12.index);
+  } else if (m24) {
+    const hour = Number(m24[1]);
+    const minute = Number(m24[2]);
+    const second = m24[3] != null ? Number(m24[3]) : 0;
+    if (hour > 23 || minute > 59 || second > 59) {
+      throw new ParseFailure("bad_time", "\"" + m24[0].trim() + "\" is not a time on a 24-hour clock.");
+    }
+    point.timeMs = (hour * 3600 + minute * 60 + second) * 1000;
+    datePart = p.slice(0, m24.index);
+  } else if (mWord) {
+    point.timeMs = mWord[1] === "noon" ? 12 * HOUR_MS : 0;
+    datePart = p.slice(0, mWord.index);
+  }
+
+  datePart = datePart.trim();
+  if (datePart.length === 0) {
+    if (point.timeMs == null) throw new ParseFailure("unrecognized", "\"" + text.trim() + "\" is not a date or a time. " + EXAMPLES);
+    return point;
+  }
+  parseDate(datePart, point, wallNow, text);
+  return point;
+}
+
+function checkCalendarEnd(wallMs) {
+  if (wallMs > LAST_DAY_MS) throw new ParseFailure("bad_date", "That date is out of range.");
+}
+
+function fixedFromWall(startWall, endWall, zone) {
+  checkCalendarEnd(endWall);
+  return fixedSpec(wallToUtcBound(startWall, zone, "from"), wallToUtcBound(endWall, zone, "to"));
+}
+
+function sinceFromPoint(start, wallNow, zone) {
+  if (start.isNow) throw new ParseFailure("bad_range", "The start cannot be now.");
+  if (start.instantMs != null) return sinceSpec(start.instantMs);
+  let wall;
+  if (start.hasDate) {
+    wall = dateFor(start, wallNow, start.timeMs) + (start.timeMs ?? 0);
+  } else {
+    /* A time alone is the latest such time that is not in the future. */
+    wall = floorDay(wallNow) + start.timeMs;
+    if (wall > wallNow) wall -= DAY_MS;
+  }
+  return sinceSpec(wallToUtcBound(wall, zone, "from"));
+}
+
+function rangeFromPoints(a, b, wallNow, zone) {
+  let aDate;
+  let bDate;
+  if (a.hasDate && b.hasDate) {
+    if (a.year == null && b.year == null) {
+      aDate = dateFor(a, wallNow, a.timeMs);
+      bDate = withYear(b, new Date(aDate).getUTCFullYear());
+      bDate = rollEndIntoNextYear(b, aDate, bDate, wallNow);
+    } else if (a.year == null) {
+      bDate = withYear(b, b.year);
+      aDate = withYear(a, new Date(bDate).getUTCFullYear());
+      if (aDate > bDate) aDate = withYear(a, new Date(bDate).getUTCFullYear() - 1);
+    } else {
+      aDate = withYear(a, a.year);
+      bDate = withYear(b, b.year ?? new Date(aDate).getUTCFullYear());
+      if (b.year == null) bDate = rollEndIntoNextYear(b, aDate, bDate, wallNow);
+    }
+    if (bDate < aDate) throw new ParseFailure("end_before_start", "The end is before the start.");
+  } else if (a.hasDate) {
+    aDate = dateFor(a, wallNow, a.timeMs);
+    bDate = aDate;
+    if (b.timeMs < (a.timeMs ?? 0)) bDate = aDate + DAY_MS;
+  } else if (b.hasDate) {
+    bDate = dateFor(b, wallNow, b.timeMs);
+    aDate = bDate;
+    if (b.timeMs != null && a.timeMs > b.timeMs) aDate = bDate - DAY_MS;
+  } else {
+    /* Two times: the latest day whose range has ended by now; an end earlier on the clock than the start is the next day. */
+    const rollsOver = b.timeMs < a.timeMs ? 1 : 0;
+    aDate = floorDay(wallNow);
+    for (let back = 0; back < 3; back++) {
+      aDate = floorDay(wallNow) - back * DAY_MS;
+      if (aDate + rollsOver * DAY_MS + b.timeMs <= wallNow) break;
+    }
+    bDate = aDate + rollsOver * DAY_MS;
+  }
+  const startWall = aDate + (a.timeMs ?? 0);
+  const endWall = b.timeMs == null ? bDate + DAY_MS : bDate + b.timeMs;
+  return fixedFromWall(startWall, endWall, zone);
+}
+
+function parseSpec(text, nowMs, zone) {
+  let s = normalize(text);
+  if (s.length === 0) throw new ParseFailure("empty", "Type a range. " + EXAMPLES);
+
+  if (PERIODS.has(s)) return calendarSpec(PERIODS.get(s));
+
+  const relative = RELATIVE_RX.exec(s);
+  if (relative && UNITS.has(relative[2])) {
+    const seconds = Number(relative[1]) * UNITS.get(relative[2]);
+    if (seconds > 36500 * 86400) throw new ParseFailure("too_far_back", "That reaches back more than 100 years.");
+    return relativeSpec(roundEven(seconds) * 1000);
+  }
+
+  const wallNow = toWall(nowMs, zone);
+  if (s.startsWith("since ")) return sinceFromPoint(parsePoint(s.slice(6), wallNow), wallNow, zone);
+  if (s.startsWith("from ")) s = s.slice(5);
+
+  const sides = splitSides(s);
+  if (sides.length === 1) {
+    const only = parsePoint(sides[0], wallNow);
+    if (only.isNow || only.instantMs != null || !only.hasDate || only.timeMs != null) {
+      throw new ParseFailure("needs_end", "Give an end as well, like \"Oct 1 12pm - 3pm\", or say \"since Oct 1 12pm\".");
+    }
+    /* One date alone is the whole day. */
+    const day = dateFor(only, wallNow, null);
+    return fixedFromWall(day, day + DAY_MS, zone);
+  }
+
+  const a = parsePoint(sides[0], wallNow);
+  const b = parsePoint(sides[1], wallNow);
+  if (a.isNow) throw new ParseFailure("bad_range", "The start cannot be now. Use \"since\" for a range that grows.");
+  if (b.isNow) return sinceFromPoint(a, wallNow, zone);
+  if (a.instantMs != null || b.instantMs != null) {
+    if (a.instantMs == null || b.instantMs == null) {
+      throw new ParseFailure("bad_range", "Use two Unix times, or two dates and times, not one of each.");
+    }
+    return fixedSpec(a.instantMs, b.instantMs);
+  }
+  return rangeFromPoints(a, b, wallNow, zone);
+}
+
+/**
+ * Reads a line of text as a range at `nowMs` in `zone`. Returns `{ ok, range, spec, echo, error, errorCode }`: `echo` is the
+ * range's one-line label (empty on an error), `error` the plain reason and `errorCode` the stable code (empty, unrecognized,
+ * bad_date, bad_time, bad_range, needs_end, too_short, end_before_start, start_in_future, too_far_back).
+ */
+export function parseRange(text, nowMs, zone) {
+  const refused = (code, message) => ({ ok: false, range: null, spec: null, echo: "", error: message, errorCode: code });
+  try {
+    const spec = parseSpec(text, nowMs, zone);
+    const r = resolveSpec(spec, nowMs, zone);
+    return r.ok
+      ? { ok: true, range: r.range, spec, echo: r.range.label, error: null, errorCode: null }
+      : refused(r.error.code, r.error.message);
+  } catch (e) {
+    if (e instanceof ParseFailure) return refused(e.code, e.message);
+    if (e instanceof RangeError) return refused("bad_date", "That date is out of range.");
+    throw e;
+  }
+}
+
+/* ───────────────────────────────── notes, reach, and the reads' window ───────────────────────────────── */
+
+/** "3 minutes" / "1 hour" / "30 seconds": a collector interval in words. */
+export function intervalText(intervalMs) {
+  let count;
+  let unit;
+  if (intervalMs % HOUR_MS === 0) {
+    count = intervalMs / HOUR_MS;
+    unit = "hour";
+  } else if (intervalMs % MINUTE_MS === 0) {
+    count = intervalMs / MINUTE_MS;
+    unit = "minute";
+  } else {
+    count = Math.max(1, Math.round(intervalMs / 1000));
+    unit = "second";
+  }
+  return count === 1 ? unit : count + " " + unit + "s";
+}
+
+/** "Data here is collected every 5 minutes." when the span holds fewer than 3 samples at the interval, else null. */
+export function sampleIntervalNote(spanMs, intervalMs) {
+  if (!(intervalMs > 0) || spanMs >= intervalMs * MIN_SAMPLES) return null;
+  return "Data here is collected every " + intervalText(intervalMs) + ".";
+}
+
+/** "Data starts Oct 3, 2:00 pm" when the range starts more than 90 minutes before the data does, else null. */
+export function dataStartNote(range, dataStartMs) {
+  if (dataStartMs == null || range.startMs >= dataStartMs - DATA_START_SLACK_MS) return null;
+  const nowYear = wallYear(range.nowMs, range.zone);
+  const showYear = wallYear(range.startMs, range.zone) !== nowYear || wallYear(range.endMs, range.zone) !== nowYear;
+  return "Data starts " + formatBound(dataStartMs, { zone: range.zone, showYear }, false);
+}
+
+/** An instant as the text a date-time box and the typed grammar both read, in the zone: "2026-10-01 13:00" (seconds only when not zero). */
+export function wallText(ms, zone) {
+  const w = new Date(toWall(ms, zone));
+  const date = w.getUTCFullYear() + "-" + pad2(w.getUTCMonth() + 1) + "-" + pad2(w.getUTCDate());
+  const clock = pad2(w.getUTCHours()) + ":" + pad2(w.getUTCMinutes()) + (w.getUTCSeconds() ? ":" + pad2(w.getUTCSeconds()) : "");
+  return date + " " + clock;
+}
+
+/**
+ * The reach of one read, in hours: the `max_hours` its /api/catalog entry carries (on the entry, or on its `hours` param), else the
+ * default (168). The catalog entry is the element of `reads` the page's active read names; with none, the default applies.
+ */
+export function reachHours(catalogEntry, fallbackHours = 168) {
+  const param = catalogEntry && Array.isArray(catalogEntry.params) ? catalogEntry.params.find((p) => p && p.name === "hours") : null;
+  for (const holder of [catalogEntry, param]) {
+    const max = holder ? Number(holder.max_hours) : NaN;
+    if (Number.isFinite(max) && max > 0) return max;
+  }
+  return fallbackHours;
+}
+
+/** "7 days" / "90 days" / "36 hours": a reach in words. */
+export function reachText(hours) {
+  return hours % 24 === 0 ? hours / 24 + " day" + (hours === 24 ? "" : "s") : hours + " hour" + (hours === 1 ? "" : "s");
+}
+
+/** The reason a range is longer than the reach (hours), or null when it fits. */
+export function reachRefusal(spanMs, hours) {
+  return spanMs > hours * HOUR_MS ? "This page's reads reach at most " + reachText(hours) + " back." : null;
+}
+
+/**
+ * The window a read takes for a resolved range: reads take whole `hours` and an `as_of` end. `hours` rounds the span UP to a whole
+ * number of hours (at least 1), so the fetch starts at or before the range start and the page trims to the exact pair; `asOf` is
+ * the end as ISO text, or null for a live range, whose reads are anchored at the server's own clock.
+ */
+export function readWindow(range) {
+  return {
+    hours: Math.max(1, Math.ceil(range.spanMs / HOUR_MS)),
+    asOf: range.live ? null : new Date(range.endMs).toISOString(),
+    live: range.live,
+    startMs: range.startMs,
+    endMs: range.endMs,
+  };
+}

From 53152d5f420e9bf910f9935998c1eb1b398cf34e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:46:45 -0400
Subject: [PATCH 07/33] The web module reads a read's collector interval from
 the catalog (#5562)

---
 Darling/Darling.Tests/WebTimeRangeTests.cs             |  2 ++
 Darling/Darling.Tests/time-range-picker-harness.mjs    |  3 ++-
 .../wwwroot/js/time-range.js                           | 10 ++++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/Darling/Darling.Tests/WebTimeRangeTests.cs b/Darling/Darling.Tests/WebTimeRangeTests.cs
index 0fa2072dab..920cd7c55d 100644
--- a/Darling/Darling.Tests/WebTimeRangeTests.cs
+++ b/Darling/Darling.Tests/WebTimeRangeTests.cs
@@ -238,6 +238,8 @@ public void TheNotesTheReachAndTheClock_FollowTheirInputs()
 
         var reach = r.GetProperty("reach");
         Assert.Equal(2160, reach.GetProperty("reach").GetInt32());
+        Assert.Equal(300000, reach.GetProperty("interval").GetInt32());
+        Assert.Equal(JsonValueKind.Null, reach.GetProperty("noInterval").ValueKind);
         Assert.Equal(168, reach.GetProperty("none").GetInt32());
         Assert.Equal(168, reach.GetProperty("absent").GetInt32());
         Assert.Equal(new[] { "Year to Date", "Previous Year" }, Strings(reach, "items"));
diff --git a/Darling/Darling.Tests/time-range-picker-harness.mjs b/Darling/Darling.Tests/time-range-picker-harness.mjs
index 51a8d7ac46..0bc4241a21 100644
--- a/Darling/Darling.Tests/time-range-picker-harness.mjs
+++ b/Darling/Darling.Tests/time-range-picker-harness.mjs
@@ -242,7 +242,8 @@ const found = {};
   const reach = tr.reachHours(entry);
   const { root, button } = make({ reachHours: reach });
   fire(button, "click");
-  found.reach = { reach, none: tr.reachHours({ name: "y", params: [] }), absent: tr.reachHours(null), items: items(root).filter((i) => i.disabled).map((i) => i.name) };
+  const interval = tr.collectorIntervalMs({ params: [{ name: "hours", collector_interval_minutes: 5 }] });
+  found.reach = { interval, noInterval: tr.collectorIntervalMs({ params: [] }), reach, none: tr.reachHours({ name: "y", params: [] }), absent: tr.reachHours(null), items: items(root).filter((i) => i.disabled).map((i) => i.name) };
 }
 
 /* 11. A live range slides: refresh() redraws at the clock it is given. setSpec reads an id back. */
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
index 19ac647cc2..8020057033 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
@@ -847,6 +847,16 @@ export function reachHours(catalogEntry, fallbackHours = 168) {
   return fallbackHours;
 }
 
+/** The main collector's interval of one read in milliseconds, from the `collector_interval_minutes` its /api/catalog entry carries (on the entry or on its `hours` param), else null (no note). */
+export function collectorIntervalMs(catalogEntry) {
+  const param = catalogEntry && Array.isArray(catalogEntry.params) ? catalogEntry.params.find((p) => p && p.name === "hours") : null;
+  for (const holder of [catalogEntry, param]) {
+    const minutes = holder ? Number(holder.collector_interval_minutes) : NaN;
+    if (Number.isFinite(minutes) && minutes > 0) return minutes * MINUTE_MS;
+  }
+  return null;
+}
+
 /** "7 days" / "90 days" / "36 hours": a reach in words. */
 export function reachText(hours) {
   return hours % 24 === 0 ? hours / 24 + " day" + (hours === 24 ? "" : "s") : hours + " hour" + (hours === 1 ? "" : "s");

From edc2a562c55a09019fc4587c1eeb9fa9f0ccbadb Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:34:21 -0400
Subject: [PATCH 08/33] Lite: every time range control uses the shared picker
 (#5562)

The server tab toolbar, the five FinOps lists and the object heatmap, Alert History,
Job History and the Settings default range now use TimeRangePicker. A rolling range of
whole hours still reaches the readers as (hours, null, null); sub-hour spans, calendar
periods and typed ranges carry their instants. default_time_range_hours keeps working
through FromLegacyHours and an optional default_time_range holds the other presets and
periods. The picker's data-start note takes the Queries probe the tab already awaits and
its sample-interval note the wait stats schedule. Lite's ApplyThemeToCalendar is gone.
---
 .../servertab-eventwires.baseline.txt         |   2 -
 Lite.Tests/QueriesTabWindowRoundTripTests.cs  |   8 +-
 Lite.Tests/RefreshCoordinatorTests.cs         |   4 +-
 Lite.Tests/ServerTabHeldRangeTests.cs         | 316 ++++++++++-----
 Lite/App.xaml.cs                              |  49 ++-
 Lite/Controls/AlertsHistoryTab.xaml           |  10 +-
 Lite/Controls/AlertsHistoryTab.xaml.cs        |   7 +-
 Lite/Controls/FinOpsTab.ObjectHeatmap.cs      |  15 +-
 Lite/Controls/FinOpsTab.xaml                  |  44 +-
 Lite/Controls/FinOpsTab.xaml.cs               |  25 +-
 Lite/Controls/JobHistoryTab.xaml              |  10 +-
 Lite/Controls/JobHistoryTab.xaml.cs           |  11 +-
 Lite/Controls/ServerTab.DrillDown.cs          |  23 +-
 Lite/Controls/ServerTab.Refresh.cs            |  31 +-
 Lite/Controls/ServerTab.TimeRange.cs          | 376 ++++--------------
 Lite/Controls/ServerTab.xaml                  |  26 +-
 Lite/Controls/ServerTab.xaml.cs               |  28 +-
 Lite/Helpers/LiteTimeRange.cs                 | 115 ++++++
 Lite/MainWindow.xaml.cs                       |  12 +-
 Lite/Windows/SettingsWindow.xaml              |   9 +-
 Lite/Windows/SettingsWindow.xaml.cs           |  32 +-
 Lite/config/settings.sample.json              |   3 +-
 22 files changed, 569 insertions(+), 587 deletions(-)
 create mode 100644 Lite/Helpers/LiteTimeRange.cs

diff --git a/Lite.Tests/CapabilityPins/servertab-eventwires.baseline.txt b/Lite.Tests/CapabilityPins/servertab-eventwires.baseline.txt
index d43b9b422b..8df0dac8ce 100644
--- a/Lite.Tests/CapabilityPins/servertab-eventwires.baseline.txt
+++ b/Lite.Tests/CapabilityPins/servertab-eventwires.baseline.txt
@@ -6,7 +6,6 @@ MouseDoubleClick=>QueryStatsGrid_MouseDoubleClick
 MouseDoubleClick=>QueryStoreGrid_MouseDoubleClick
 SelectionChanged=>AutoRefreshInterval_Changed
 SelectionChanged=>CompareToCombo_SelectionChanged
-SelectionChanged=>CustomTimeCombo_Changed
 SelectionChanged=>HeatmapMetric_SelectionChanged
 SelectionChanged=>MainTabControl_SelectionChanged
 SelectionChanged=>PerfmonPack_SelectionChanged
@@ -14,5 +13,4 @@ SelectionChanged=>ProcedureStatsGrid_SelectionChanged
 SelectionChanged=>QueryStatsGrid_SelectionChanged
 SelectionChanged=>QueryStoreGrid_SelectionChanged
 SelectionChanged=>TimeDisplayMode_SelectionChanged
-SelectionChanged=>TimeRangeCombo_SelectionChanged
 SelectionChanged=>WaitStatsMetric_SelectionChanged
diff --git a/Lite.Tests/QueriesTabWindowRoundTripTests.cs b/Lite.Tests/QueriesTabWindowRoundTripTests.cs
index 177acec061..d7f16fd385 100644
--- a/Lite.Tests/QueriesTabWindowRoundTripTests.cs
+++ b/Lite.Tests/QueriesTabWindowRoundTripTests.cs
@@ -103,10 +103,10 @@ public void EveryDisplayMode_ReadsTheInstantThePickerShows(TimeDisplayMode mode)
             var toInstant = Utc(to);
 
             var zone = PerformanceMonitorLite.Controls.ServerTab.PickerZone(mode, clock);
-            var held = new PerformanceMonitor.Ui.CustomRangeState();
-            held.Set(fromInstant, toInstant);
-            Assert.NotNull(held.Render(zone));
-            var (_, heldFrom, heldTo) = PerformanceMonitorLite.Controls.ServerTab.CurrentWindowUtc(24, true, held);
+            /* #5562: the range the tab holds is a fixed range on the shared picker; the zone only words it. */
+            var spec = PerformanceMonitor.Ui.TimeRangeSpec.FixedRange(fromInstant, toInstant);
+            Assert.True(spec.TryResolve(toInstant.AddDays(1), zone, out var resolved, out _));
+            var (_, heldFrom, heldTo) = PerformanceMonitorLite.Helpers.LiteTimeRange.WindowFor(resolved!);
             var (start, end) = LocalDataService.GetQueriesTabWindowUtc(24, heldFrom, heldTo);
 
             Assert.Equal(Range(fromInstant, toInstant), Range(start, end));
diff --git a/Lite.Tests/RefreshCoordinatorTests.cs b/Lite.Tests/RefreshCoordinatorTests.cs
index 2ecd204070..de481578ad 100644
--- a/Lite.Tests/RefreshCoordinatorTests.cs
+++ b/Lite.Tests/RefreshCoordinatorTests.cs
@@ -466,9 +466,7 @@ public void TheTimerTick_IsAPoll_ThroughTheCoordinator()
     }
 
     [Theory]
-    [InlineData("TimeRangeCombo_SelectionChanged")]
-    [InlineData("CustomDateRange_Changed")]
-    [InlineData("CustomTimeCombo_Changed")]
+    [InlineData("RangePicker_RangeChanged")]
     public void TheTimeRangeHandlers_DoNotDropAChangeBecauseARefreshIsRunning(string handler)
     {
         var body = Body("ServerTab.TimeRange.cs", handler);
diff --git a/Lite.Tests/ServerTabHeldRangeTests.cs b/Lite.Tests/ServerTabHeldRangeTests.cs
index 399ee67b63..4b69550111 100644
--- a/Lite.Tests/ServerTabHeldRangeTests.cs
+++ b/Lite.Tests/ServerTabHeldRangeTests.cs
@@ -13,34 +13,35 @@
 using PerformanceMonitor.Analysis.Baselines;
 using PerformanceMonitor.Ui;
 using PerformanceMonitorLite.Controls;
+using PerformanceMonitorLite.Helpers;
+using PerformanceMonitorLite.Services;
 using Xunit;
 
 namespace PerformanceMonitorLite.Tests;
 
 /// <summary>
-/// #4766: the Server tab holds its custom range as two UTC instants (<see cref="CustomRangeState"/>) and the pickers
-/// on the toolbar only show it. The window a refresh reads is the pair as held, whatever zone the pickers are drawn
-/// in; a switch of display mode draws the same pair in the new zone and parses nothing back.
+/// #5562: the Server tab holds its range on the shared picker, and the window a refresh reads comes from
+/// <see cref="LiteTimeRange.WindowFor"/>: a rolling range of whole hours is still (hours, null, null), exactly as the
+/// old presets were, and everything else (a sub-hour span, a calendar period, a typed range) carries the two instants
+/// it resolves to, so the ~60 consumers of <c>GetCurrentWindowUtc</c> / <c>GetHoursBack</c> / <c>GetChartWindow</c>
+/// need no change. The tab is a WPF control this suite does not instantiate (the shared picker has its own STA tests in
+/// Darling.Tests): the mapping, the settings split and the zone are pure and tested here directly, and the wiring
+/// around them is a source pin.
 ///
-/// <para>A range whose start is 06:30 UTC on 1 November is the case that needs this. On a US Eastern server that
-/// instant is the SECOND 01:30 of the day (the clocks fall back at 06:00 UTC), and the picker text "01:30" names the
-/// first (05:30 UTC). Read the text back after a redraw and the range moves an hour, so the redraw must not be read
-/// as the user typing. The tab is a WPF control this suite does not instantiate: the window and the zone are pure
-/// static methods tested here directly, and the wiring around them is a source pin.</para>
+/// <para>#4766 still holds: a fixed range holds its instants itself, so the zone only changes the text. A range from
+/// 06:30 UTC on 1 November is the second 01:30 on a US Eastern server, and it reads 06:30 UTC in every display mode.</para>
 /// </summary>
 public sealed class ServerTabHeldRangeTests
 {
     private static ServerClock Eastern() => ServerClock.Resolve("Eastern Standard Time", -300);
 
-    private static DateTime At(int day, int hour, int minute) =>
-        new(2026, 11, day, hour, minute, 0, DateTimeKind.Unspecified);
+    private static DateTime At(int month, int day, int hour, int minute) =>
+        new(2026, month, day, hour, minute, 0, DateTimeKind.Unspecified);
 
-    /* A range from the second 01:30 to the second 02:30 of the change day, as the tab holds it. */
-    private static CustomRangeState Held()
+    private static ResolvedTimeRange Resolve(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
     {
-        var held = new CustomRangeState();
-        held.Set(At(1, 6, 30), At(1, 7, 30));
-        return held;
+        Assert.True(spec.TryResolve(nowUtc, zone, out var range, out var error), error?.Message);
+        return range!;
     }
 
     // ── The window a refresh reads ──
@@ -49,29 +50,76 @@ private static CustomRangeState Held()
     [InlineData(TimeDisplayMode.UTC)]
     [InlineData(TimeDisplayMode.LocalTime)]
     [InlineData(TimeDisplayMode.ServerTime)]
-    public void AHeldRange_IsTheWindow_WhateverZoneThePickersAreDrawnIn(TimeDisplayMode mode)
+    public void AFixedRange_IsTheWindow_WhateverZoneThePickerIsDrawnIn(TimeDisplayMode mode)
     {
-        var held = Held();
         var zone = ServerTab.PickerZone(mode, Eastern());
+        var spec = TimeRangeSpec.FixedRange(At(11, 1, 6, 30), At(11, 1, 7, 30));
 
-        /* The pickers are drawn in this zone. Drawing them reads the pair and writes nothing. */
-        Assert.NotNull(held.Render(zone));
+        var (hoursBack, fromUtc, toUtc) = LiteTimeRange.WindowFor(Resolve(spec, At(11, 5, 12, 0), zone));
 
-        var (hoursBack, fromUtc, toUtc) = ServerTab.CurrentWindowUtc(4, customSelected: true, held);
+        Assert.Equal(At(11, 1, 6, 30), fromUtc);
+        Assert.Equal(At(11, 1, 7, 30), toUtc);
+        /* Hours from the start to now, rounded up: 4 days and 5.5 hours. */
+        Assert.Equal(102, hoursBack);
+    }
 
-        Assert.Equal(4, hoursBack);
-        Assert.Equal(At(1, 6, 30), fromUtc);
-        Assert.Equal(At(1, 7, 30), toUtc);
+    [Theory]
+    [InlineData(1)]
+    [InlineData(4)]
+    [InlineData(12)]
+    [InlineData(24)]
+    [InlineData(168)]
+    public void ARollingRangeOfWholeHours_HasNoBounds_LikeTheOldPresets(int hours)
+    {
+        var spec = TimeRangePresets.FromLegacyHours(hours)!;
+
+        Assert.Equal((hours, (DateTime?)null, (DateTime?)null), LiteTimeRange.WindowFor(Resolve(spec, At(10, 8, 12, 0), TimeZoneInfo.Utc)));
+    }
+
+    [Theory]
+    [InlineData(5, 1)]
+    [InlineData(15, 1)]
+    [InlineData(30, 1)]
+    [InlineData(90, 2)]
+    public void ASubHourOrFractionalSpan_CarriesItsInstants_AndHoursBackRoundsUp(int minutes, int expectedHoursBack)
+    {
+        var now = At(10, 8, 12, 0);
+        var spec = TimeRangeSpec.Relative(TimeSpan.FromMinutes(minutes));
+
+        var (hoursBack, fromUtc, toUtc) = LiteTimeRange.WindowFor(Resolve(spec, now, TimeZoneInfo.Utc));
+
+        Assert.Equal(expectedHoursBack, hoursBack);
+        Assert.Equal(now.AddMinutes(-minutes), fromUtc);
+        Assert.Equal(now, toUtc);
     }
 
     [Fact]
-    public void APresetOrAnEmptyHold_HasNoBounds()
+    public void ACalendarPeriod_FlowsThroughAsTheDisplayZonesWallClockDay()
     {
-        var held = Held();
-        Assert.Equal((4, (DateTime?)null, (DateTime?)null), ServerTab.CurrentWindowUtc(4, customSelected: false, held));
+        /* 'Yesterday' on an Eastern server read at 08 Oct 2026 12:00 UTC (08:00 there) is 7 Oct 00:00 to 8 Oct 00:00 Eastern. */
+        var zone = ServerTab.PickerZone(TimeDisplayMode.ServerTime, Eastern());
+        var now = At(10, 8, 12, 0);
+        var spec = TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday);
+        var range = Resolve(spec, now, zone);
+
+        var (hoursBack, fromUtc, toUtc) = LiteTimeRange.WindowFor(range);
+
+        Assert.Equal(At(10, 7, 4, 0), fromUtc);
+        Assert.Equal(At(10, 8, 4, 0), toUtc);
+        Assert.Equal(32, hoursBack);
+
+        /* The chart axis for it is that pair, not 'now - hoursBack'. */
+        Assert.Equal((At(10, 7, 4, 0), At(10, 8, 4, 0)), ServerTab.GetChartWindow(hoursBack, fromUtc, toUtc, now));
+        Assert.True(LiteTimeRange.HasExplicitInstants(range));
+    }
 
-        var nothingHeldYet = new CustomRangeState();
-        Assert.Equal((24, (DateTime?)null, (DateTime?)null), ServerTab.CurrentWindowUtc(24, customSelected: true, nothingHeldYet));
+    [Fact]
+    public void ARollingWholeHourRange_IsNotExplicit_ASlidingOneIs()
+    {
+        var now = At(10, 8, 12, 0);
+        Assert.False(LiteTimeRange.HasExplicitInstants(Resolve(TimeRangeSpec.Relative(TimeSpan.FromHours(4)), now, TimeZoneInfo.Utc)));
+        Assert.True(LiteTimeRange.HasExplicitInstants(Resolve(TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)), now, TimeZoneInfo.Utc)));
+        Assert.True(LiteTimeRange.HasExplicitInstants(Resolve(TimeRangeSpec.SinceInstant(At(10, 7, 0, 0)), now, TimeZoneInfo.Utc)));
     }
 
     [Fact]
@@ -84,96 +132,178 @@ public void ThePickerZone_IsUtc_ThisMachinesZone_OrTheTabsOwnServerClock()
 
         /* The zone of the clock the tab was handed, so a tab that is not the selected one keeps its own server's zone. */
         var server = ServerTab.PickerZone(TimeDisplayMode.ServerTime, clock);
-        Assert.Equal(TimeSpan.FromHours(-4), server.GetUtcOffset(DateTime.SpecifyKind(At(1, 5, 30), DateTimeKind.Utc)));
-        Assert.Equal(TimeSpan.FromHours(-5), server.GetUtcOffset(DateTime.SpecifyKind(At(1, 6, 30), DateTimeKind.Utc)));
+        Assert.Equal(TimeSpan.FromHours(-4), server.GetUtcOffset(DateTime.SpecifyKind(At(11, 1, 5, 30), DateTimeKind.Utc)));
+        Assert.Equal(TimeSpan.FromHours(-5), server.GetUtcOffset(DateTime.SpecifyKind(At(11, 1, 6, 30), DateTimeKind.Utc)));
     }
 
     [Fact]
-    public void ADisplayModeRoundTrip_ServerThenUtcThenServer_LeavesTheHeldInstantsAlone()
+    public void ADrillWindowUnderTheFiveMinuteFloor_IsCentredAndHeldAtFiveMinutes()
     {
-        var held = Held();
-        var clock = Eastern();
-        var serverZone = ServerTab.PickerZone(TimeDisplayMode.ServerTime, clock);
-        var utcZone = ServerTab.PickerZone(TimeDisplayMode.UTC, clock);
+        var (from, to) = LiteTimeRange.AtLeastMinimumSpan(At(10, 8, 12, 0), At(10, 8, 12, 2));
+        Assert.Equal((At(10, 8, 11, 58).AddSeconds(30), At(10, 8, 12, 3).AddSeconds(30)), (from, to));
 
-        var inServer = held.Render(serverZone);
-        var inUtc = held.Render(utcZone);
-        var inServerAgain = held.Render(serverZone);
+        var longer = (At(10, 8, 12, 0), At(10, 8, 12, 30));
+        Assert.Equal(longer, LiteTimeRange.AtLeastMinimumSpan(longer.Item1, longer.Item2));
+    }
+
+    // ── Settings: the legacy hours key keeps working, default_time_range is optional ──
+
+    [Theory]
+    [InlineData(1, "1h")]
+    [InlineData(4, "4h")]
+    [InlineData(12, "12h")]
+    [InlineData(24, "1d")]
+    [InlineData(168, "1w")]
+    [InlineData(48, "2d")]
+    public void TheLegacyHoursKey_MapsThroughFromLegacyHours(int hours, string expectedId)
+    {
+        Assert.Equal(expectedId, LiteTimeRange.FromSettings(null, hours).Id);
+        Assert.Equal(expectedId, LiteTimeRange.FromSettings("", hours).Id);
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-3)]
+    public void ANonsenseLegacyValue_OpensOnFourHours(int hours)
+    {
+        Assert.Equal("4h", LiteTimeRange.FromSettings(null, hours).Id);
+    }
 
-        /* 06:30 UTC is 01:30 on the server's clock, and 07:30 UTC is 02:30 there. */
-        Assert.Equal((At(1, 1, 30), At(1, 2, 30)), inServer);
-        Assert.Equal((At(1, 6, 30), At(1, 7, 30)), inUtc);
-        Assert.Equal(inServer, inServerAgain);
+    [Fact]
+    public void TheNewKey_WinsForAPresetOrAPeriod_AndANonPersistableOneFallsBackToTheHours()
+    {
+        Assert.Equal("30m", LiteTimeRange.FromSettings("30m", 24).Id);
+        Assert.Equal("previous-week", LiteTimeRange.FromSettings("previous-week", 24).Id);
+        Assert.Equal("1mo", LiteTimeRange.FromSettings("1mo", 4).Id);
+
+        /* A typed range is never taken from a file, and neither is text that is not a range. */
+        Assert.Equal("12h", LiteTimeRange.FromSettings("fixed:2026-10-01T04:00:00Z/2026-10-02T04:00:00Z", 12).Id);
+        Assert.Equal("12h", LiteTimeRange.FromSettings("since:2026-10-01T04:00:00Z", 12).Id);
+        Assert.Equal("12h", LiteTimeRange.FromSettings("nonsense", 12).Id);
+    }
 
-        Assert.Equal(At(1, 6, 30), held.FromUtc);
-        Assert.Equal(At(1, 7, 30), held.ToUtc);
-        Assert.Equal(At(1, 6, 30), ServerTab.CurrentWindowUtc(4, customSelected: true, held).fromUtc);
+    [Fact]
+    public void WhatIsWritten_WholeHoursGoToTheLegacyKey_OtherPresetsToTheNewOne_ATypedRangeToNeither()
+    {
+        Assert.Equal(((string?)null, (int?)4), LiteTimeRange.SettingsFor(TimeRangePresets.FromLegacyHours(4)!));
+        Assert.Equal(((string?)null, (int?)24), LiteTimeRange.SettingsFor(TimeRangePresets.FromLegacyHours(24)!));
+        Assert.Equal(("15m", (int?)null), LiteTimeRange.SettingsFor(TimeRangeSpec.Relative(TimeSpan.FromMinutes(15))));
+        Assert.Equal(("previous-week", (int?)null), LiteTimeRange.SettingsFor(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek)));
+        Assert.Equal(((string?)null, (int?)null), LiteTimeRange.SettingsFor(TimeRangeSpec.FixedRange(At(10, 1, 0, 0), At(10, 2, 0, 0))));
+        Assert.Equal(((string?)null, (int?)null), LiteTimeRange.SettingsFor(TimeRangeSpec.SinceInstant(At(10, 1, 0, 0))));
     }
 
-    /// <summary>
-    /// The fact that makes the redraw guard necessary. The pickers show the second 01:30 as the text "01:30". Read
-    /// back as a typed edit, "01:30" as the start of a range is the FIRST 01:30, 05:30 UTC: an hour earlier than the
-    /// range that was held. So a picker write made by the tab itself must never reach the edit path.
-    /// </summary>
     [Fact]
-    public void ReadingTheRenderedServerTextBackAsAnEdit_MovesA0630ZStartTo0530Z()
+    public void TheTwoKeysNeverDisagree_ChoosingAWholeHourRangeClearsTheNewKey()
     {
-        var held = Held();
-        var serverZone = ServerTab.PickerZone(TimeDisplayMode.ServerTime, Eastern());
-        var shown = held.Render(serverZone)!.Value;
-        Assert.Equal(At(1, 1, 30), shown.From);
+        var root = new System.Text.Json.Nodes.JsonObject { ["default_time_range"] = "previous-week", ["default_time_range_hours"] = 4 };
 
-        var edited = held.ApplyEdit(shown.From, BoundSide.From, serverZone);
+        App.WriteDefaultTimeRange(root, null, 12);
+        Assert.Equal(12, (int)root["default_time_range_hours"]!);
+        Assert.False(root.ContainsKey("default_time_range"));
 
-        Assert.Equal(At(1, 5, 30), edited);
-        Assert.Equal(At(1, 5, 30), held.FromUtc);
-        Assert.Equal(At(1, 7, 30), held.ToUtc);
+        App.WriteDefaultTimeRange(root, "30m", null);
+        Assert.Equal("30m", (string?)root["default_time_range"]);
+        Assert.Equal(12, (int)root["default_time_range_hours"]!);
     }
 
-    // ── The wiring: source pins on Lite/Controls/ServerTab.TimeRange.cs ──
+    // ── Notes: the retention start and the collector's interval ──
 
-    /// <summary>
-    /// The display-mode switch draws the held range in the new zone and calls nothing that reads the pickers'
-    /// text: not the parse itself and not the capture that wraps it. Comments are stripped, so a sentence that names
-    /// them cannot fail the pin.
-    /// </summary>
     [Fact]
-    public void TheDisplayModeSwitch_DrawsTheHeldRange_AndParsesNothing()
+    public void TheDataStart_IsTheProbedFloor_ElseTheStaticRetentionEdge()
     {
-        var body = MethodBody(CodeOnly(ReadTimeRangeSource()), "private async void TimeDisplayMode_SelectionChanged(");
+        var now = At(10, 8, 12, 0);
+        var floor = At(10, 3, 14, 0);
+
+        Assert.Equal(floor, LiteTimeRange.DataStartFor(floor, now));
+        Assert.Equal(RetentionService.OldestRetainedInstant(now), LiteTimeRange.DataStartFor(null, now));
 
-        Assert.Contains("RenderCustomRange();", body, StringComparison.Ordinal);
-        Assert.DoesNotContain("GetDateTimeFromPickers", body, StringComparison.Ordinal);
-        Assert.DoesNotContain("CaptureCustomRangeEdit", body, StringComparison.Ordinal);
+        /* The picker words it from the range: a start well before the data start shows the note, one after it does not. */
+        var long30 = Resolve(TimeRangeSpec.Relative(TimeSpan.FromDays(30)), now, TimeZoneInfo.Utc);
+        Assert.StartsWith("Data starts", TimeRangeNotes.DataStartNote(long30, floor));
+        Assert.Null(TimeRangeNotes.DataStartNote(Resolve(TimeRangeSpec.Relative(TimeSpan.FromHours(4)), now, TimeZoneInfo.Utc), floor));
     }
 
-    /// <summary>
-    /// <c>RenderCustomRange</c> raises <c>_renderingCustomRange</c> before its first picker write and lowers it in a
-    /// <c>finally</c>, and both picker handlers return on it before they reach <c>CaptureCustomRangeEdit</c>, so the
-    /// tab's own writes are never read as an edit.
-    /// </summary>
+    [Theory]
+    [InlineData(1, 5, false)]
+    [InlineData(15, 30, true)]
+    [InlineData(5, 10, true)]
+    [InlineData(5, 15, false)]
+    [InlineData(0, 5, false)]
+    public void TheSampleInterval_IsTheCollectorsActualCadence_AndAShortSpanShowsTheNote(int minutes, int spanMinutes, bool noteShown)
+    {
+        var interval = LiteTimeRange.SampleIntervalFor(minutes);
+        var span = TimeSpan.FromMinutes(spanMinutes);
+
+        if (minutes == 0)
+        {
+            Assert.Null(interval);
+        }
+        else
+        {
+            Assert.Equal(TimeSpan.FromMinutes(minutes), interval);
+        }
+
+        Assert.Equal(noteShown, TimeRangeNotes.SampleIntervalNote(span, interval) != null);
+    }
+
+    // ── The wiring: source pins on the tab's files ──
+
     [Fact]
-    public void TheTabsOwnPickerWrites_AreMarked_AndBothPickerHandlersIgnoreThem()
+    public void TheDisplayModeSwitch_DrawsThePickerAgain_AndParsesNothing()
     {
-        var source = CodeOnly(ReadTimeRangeSource());
+        var body = MethodBody(CodeOnly(ReadControl("ServerTab.TimeRange.cs")), "private async void TimeDisplayMode_SelectionChanged(");
+
+        Assert.Contains("RangePicker.Refresh();", body, StringComparison.Ordinal);
+    }
 
-        var render = MethodBody(source, "private void RenderCustomRange(");
-        var raised = render.IndexOf("_renderingCustomRange = true;", StringComparison.Ordinal);
-        var firstWrite = render.IndexOf("FromDatePicker.SelectedDate", StringComparison.Ordinal);
-        var lowered = render.IndexOf("_renderingCustomRange = false;", StringComparison.Ordinal);
-        var finallyBlock = render.IndexOf("finally", StringComparison.Ordinal);
-        Assert.True(raised >= 0 && raised < firstWrite, "RenderCustomRange has to raise _renderingCustomRange before it writes a picker.");
-        Assert.True(finallyBlock > firstWrite && lowered > finallyBlock, "RenderCustomRange has to lower _renderingCustomRange in a finally.");
+    [Fact]
+    public void TheToolbar_HoldsTheSharedPicker_AndNoneOfTheOldControls()
+    {
+        var xaml = ReadControl("ServerTab.xaml");
 
-        foreach (var signature in new[] { "private async void CustomDateRange_Changed(", "private async void CustomTimeCombo_Changed(" })
+        Assert.Contains("<ui:TimeRangePicker x:Name=\"RangePicker\"", xaml, StringComparison.Ordinal);
+        foreach (var gone in new[] { "TimeRangeCombo", "FromDatePicker", "ToDatePicker", "FromHourCombo", "ToHourCombo", "FromMinuteCombo", "ToMinuteCombo" })
         {
-            var handler = MethodBody(source, signature);
-            var guard = Regex.Match(handler, @"\|\|\s*_renderingCustomRange\s*\)\s*return;");
-            var capture = handler.IndexOf("CaptureCustomRangeEdit(", StringComparison.Ordinal);
-
-            Assert.True(guard.Success, $"{signature} has to return while _renderingCustomRange is set.");
-            Assert.True(capture > guard.Index, $"{signature} has to return on _renderingCustomRange before CaptureCustomRangeEdit.");
+            Assert.DoesNotContain(gone, xaml, StringComparison.Ordinal);
         }
+
+        /* Apply to All, Compare and the display-mode combo stay beside it. */
+        Assert.Contains("ApplyTimeRangeToAll_Click", xaml, StringComparison.Ordinal);
+        Assert.Contains("CompareToCombo", xaml, StringComparison.Ordinal);
+        Assert.Contains("TimeDisplayModeBox", xaml, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ThePickersChoice_IsRemembered_AndNeverDropsAChangeBecauseARefreshIsRunning()
+    {
+        var body = MethodBody(CodeOnly(ReadControl("ServerTab.TimeRange.cs")), "private async void RangePicker_RangeChanged(");
+
+        Assert.DoesNotContain("_isRefreshing", body, StringComparison.Ordinal);
+        Assert.Contains("_suppressRangeRefresh", body, StringComparison.Ordinal);
+        Assert.Contains("PersistSelectedTimeRange(e.Spec);", body, StringComparison.Ordinal);
+        Assert.Contains("RefreshAllDataAsync()", body, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TheQueryStatsProbe_FeedsThePickersDataStart_WithoutANewQuery()
+    {
+        var refresh = CodeOnly(ReadControl("ServerTab.Refresh.cs"));
+        var body = MethodBody(refresh, "private async System.Threading.Tasks.Task RefreshWindowTruncatedBannerAsync(");
+
+        Assert.Contains("RangePicker.DataStartUtc = LiteTimeRange.DataStartFor(floor, DateTime.UtcNow);", body, StringComparison.Ordinal);
+        Assert.Single(Regex.Matches(body, @"GetQueryWindowFloorAsync\("));
+    }
+
+    [Fact]
+    public void TheCurrentWindow_ComesFromThePicker_AndTheTabSetsItsZoneAndDefault()
+    {
+        var refresh = CodeOnly(ReadControl("ServerTab.Refresh.cs"));
+        Assert.Contains("LiteTimeRange.WindowFor(CurrentRange())", MethodBody(refresh, "private (int hoursBack, DateTime? fromUtc, DateTime? toUtc) GetCurrentWindowUtc("), StringComparison.Ordinal);
+
+        var ctor = CodeOnly(ReadControl("ServerTab.xaml.cs"));
+        Assert.Contains("RangePicker.ZoneProvider = GetPickerZone;", ctor, StringComparison.Ordinal);
+        Assert.Contains("RangePicker.Value = App.DefaultTimeRange;", ctor, StringComparison.Ordinal);
     }
 
     /* The text of the method that starts at the signature, up to its closing brace: these files indent members by four
@@ -195,7 +325,7 @@ private static string CodeOnly(string source)
         return Regex.Replace(lf, @"//[^\n]*", string.Empty);
     }
 
-    private static string ReadTimeRangeSource([CallerFilePath] string thisFile = "") =>
+    private static string ReadControl(string name, [CallerFilePath] string thisFile = "") =>
         File.ReadAllText(Path.GetFullPath(Path.Combine(
-            Path.GetDirectoryName(thisFile)!, "..", "Lite", "Controls", "ServerTab.TimeRange.cs")));
+            Path.GetDirectoryName(thisFile)!, "..", "Lite", "Controls", name)));
 }
diff --git a/Lite/App.xaml.cs b/Lite/App.xaml.cs
index 4b0f368686..b7d4a08159 100644
--- a/Lite/App.xaml.cs
+++ b/Lite/App.xaml.cs
@@ -102,6 +102,48 @@ being handed back the stale in-memory version. The coordinator owns the mutex +
     /// </summary>
     public static int DefaultTimeRangeHours { get; set; } = 4;
 
+    /// <summary>
+    /// #5562: the default range as a picker id ("30m", "2d", "previous-week"), read from <c>default_time_range</c> when the
+    /// file names a preset or a calendar period the legacy hours key cannot spell. Null means "use
+    /// <see cref="DefaultTimeRangeHours"/>". <see cref="DefaultTimeRange"/> is the one place the two meet.
+    /// </summary>
+    public static string? DefaultTimeRangeId { get; set; }
+
+    /// <summary>The range a new server tab opens on: <see cref="DefaultTimeRangeId"/> when set, else <see cref="DefaultTimeRangeHours"/> (the old key, kept readable).</summary>
+    public static PerformanceMonitor.Ui.TimeRangeSpec DefaultTimeRange =>
+        Helpers.LiteTimeRange.FromSettings(DefaultTimeRangeId, DefaultTimeRangeHours);
+
+    /// <summary>Holds a chosen default in memory: a whole-hour range in the legacy hours value (clearing the id), anything else in the id.</summary>
+    internal static void ApplyDefaultTimeRange(string? rangeId, int? hours)
+    {
+        if (hours is { } h)
+        {
+            DefaultTimeRangeHours = h;
+            DefaultTimeRangeId = null;
+        }
+        else
+        {
+            DefaultTimeRangeId = rangeId;
+        }
+    }
+
+    /// <summary>Writes a chosen default into the settings document: the same split as <see cref="ApplyDefaultTimeRange"/>, so the two keys never disagree.</summary>
+    internal static void WriteDefaultTimeRange(System.Text.Json.Nodes.JsonNode root, string? rangeId, int? hours)
+    {
+        if (hours is { } h)
+        {
+            root["default_time_range_hours"] = h;
+            if (root is System.Text.Json.Nodes.JsonObject o)
+            {
+                o.Remove("default_time_range");
+            }
+        }
+        else
+        {
+            root["default_time_range"] = rangeId;
+        }
+    }
+
     /// <summary>
     /// Whether the server-tab auto-refresh timer starts running (#3479). One preference across every
     /// tab, like <see cref="DefaultTimeRangeHours"/> above: the reporter's mental model is "the app's
@@ -1005,6 +1047,11 @@ setting nothing reads. (Which is also why the call is not written out in this co
                 DefaultTimeRangeHours = val.WholeNumber(DefaultTimeRangeHours);
             }
 
+            if (read.TryGetProperty("default_time_range", out var rangeId))
+            {
+                DefaultTimeRangeId = rangeId.Text(DefaultTimeRangeId ?? "");
+            }
+
             /* #3479: written by ServerTab.PersistAutoRefresh when the toolbar controls change, read only
                here. No range check on the seconds — legality is the restore switch's job (a value the
                combo does not offer restores the XAML default), which is the same division of labor
@@ -1044,7 +1091,7 @@ the others. */
                EXPECTED lands here any more. Kept because an unexpected throw must not take startup down. */
             AppLogger.Warn("Settings",
                 $"settings.json tab-default keys could not be read ({ex.Message}); the defaults " +
-                $"({DefaultTimeRangeHours} hour range, auto-refresh {(AutoRefreshEnabled ? "on" : "off")} " +
+                $"({DefaultTimeRange.Id} range, auto-refresh {(AutoRefreshEnabled ? "on" : "off")} " +
                 $"at {AutoRefreshIntervalSeconds}s) are in use.");
         }
     }
diff --git a/Lite/Controls/AlertsHistoryTab.xaml b/Lite/Controls/AlertsHistoryTab.xaml
index ffadd8cfb0..627b29eb94 100644
--- a/Lite/Controls/AlertsHistoryTab.xaml
+++ b/Lite/Controls/AlertsHistoryTab.xaml
@@ -1,6 +1,7 @@
 <UserControl x:Class="PerformanceMonitorLite.Controls.AlertsHistoryTab"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ui="clr-namespace:PerformanceMonitor.Ui;assembly=PerformanceMonitor.Ui"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              mc:Ignorable="d"
@@ -77,14 +78,7 @@
                        Foreground="{DynamicResource ForegroundBrush}"/>
             <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="5,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
-            <ComboBox x:Name="TimeRangeComboBox" Width="100" VerticalAlignment="Center"
-                      SelectionChanged="TimeRangeComboBox_SelectionChanged">
-                <ComboBoxItem Content="Last 1 Hour" Tag="1"/>
-                <ComboBoxItem Content="Last 4 Hours" Tag="4"/>
-                <ComboBoxItem Content="Last 24 Hours" Tag="24" IsSelected="True"/>
-                <ComboBoxItem Content="Last 7 Days" Tag="168"/>
-                <ComboBoxItem Content="All" Tag="8760"/>
-            </ComboBox>
+            <ui:TimeRangePicker x:Name="RangePicker" VerticalAlignment="Center" RangeChanged="RangePicker_RangeChanged"/>
             <TextBlock Text="Server:" VerticalAlignment="Center" Margin="12,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
             <ComboBox x:Name="ServerFilterComboBox" Width="160" VerticalAlignment="Center"
diff --git a/Lite/Controls/AlertsHistoryTab.xaml.cs b/Lite/Controls/AlertsHistoryTab.xaml.cs
index a9e3065838..3a09605bd7 100644
--- a/Lite/Controls/AlertsHistoryTab.xaml.cs
+++ b/Lite/Controls/AlertsHistoryTab.xaml.cs
@@ -62,6 +62,7 @@ public partial class AlertsHistoryTab : UserControl
     public AlertsHistoryTab()
     {
         InitializeComponent();
+        RangePicker.Value = TimeRangePresets.FromLegacyHours(24)!; /* 24 hours, as the list opened */
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
@@ -253,9 +254,7 @@ private void PopulateServerFilter(List<AlertHistoryRow> alerts)
 
     private int GetSelectedHoursBack()
     {
-        if (TimeRangeComboBox.SelectedItem is ComboBoxItem item && item.Tag is string tagStr)
-            return int.TryParse(tagStr, out var hours) ? hours : 24;
-        return 24;
+        return LiteTimeRange.HoursBackOf(RangePicker, 24);
     }
 
     private int? GetSelectedServerId()
@@ -358,7 +357,7 @@ private void UpdateStaleDataIndicator()
 
     #region Event Handlers
 
-    private async void TimeRangeComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    private async void RangePicker_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (IsLoaded)
             await LoadAlertsAsync();
diff --git a/Lite/Controls/FinOpsTab.ObjectHeatmap.cs b/Lite/Controls/FinOpsTab.ObjectHeatmap.cs
index 1fcd59ebf0..37cb29afd9 100644
--- a/Lite/Controls/FinOpsTab.ObjectHeatmap.cs
+++ b/Lite/Controls/FinOpsTab.ObjectHeatmap.cs
@@ -17,6 +17,7 @@
 using System.Windows.Media;
 using PerformanceMonitor.Common;
 using PerformanceMonitor.Ui;
+using PerformanceMonitorLite.Helpers;
 using PerformanceMonitorLite.Services;
 
 namespace PerformanceMonitorLite.Controls;
@@ -44,13 +45,9 @@ private enum StorageDrillLevel { Parent, Objects, Indexes }
     private TextBlock? _objHeatmapPopupText;
     private DateTime _lastObjHeatmapHover;
 
-    private int GetObjectHeatmapDaysBack() => ObjectHeatmapWindowCombo?.SelectedIndex switch
-    {
-        0 => 7,
-        1 => 30,
-        2 => 90,
-        _ => 30
-    };
+    /// <summary>The heatmap reads whole days (#5562): the picker's range rounded up to days, at least 1; 30 when it cannot be used right now.</summary>
+    private int GetObjectHeatmapDaysBack() =>
+        Math.Max(1, (int)Math.Ceiling(LiteTimeRange.HoursBackOf(ObjectHeatmapWindowPicker, 720) / 24.0));
 
     /// <summary>Resets the Storage Growth drill back to the per-database parent view (server change / refresh).</summary>
     private void ResetStorageDrill()
@@ -68,7 +65,7 @@ private void ShowStorageView(StorageDrillLevel level)
 
         StorageBackButton.Visibility = level == StorageDrillLevel.Parent ? Visibility.Collapsed : Visibility.Visible;
         var windowVisible = level == StorageDrillLevel.Objects ? Visibility.Visible : Visibility.Collapsed;
-        ObjectHeatmapWindowCombo.Visibility = windowVisible;
+        ObjectHeatmapWindowPicker.Visibility = windowVisible;
         ObjectHeatmapWindowLabel.Visibility = windowVisible;
 
         StorageBreadcrumb.Text = level switch
@@ -105,7 +102,7 @@ private void StorageGrowthBack_Click(object sender, RoutedEventArgs e)
             ShowStorageView(StorageDrillLevel.Parent);
     }
 
-    private async void ObjectHeatmapWindow_Changed(object sender, SelectionChangedEventArgs e)
+    private async void ObjectHeatmapWindow_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded || _dataService == null) return;
         if (_storageLevel != StorageDrillLevel.Objects || string.IsNullOrEmpty(_objDrillDb)) return;
diff --git a/Lite/Controls/FinOpsTab.xaml b/Lite/Controls/FinOpsTab.xaml
index 356b4fc5e7..4b89ea985f 100644
--- a/Lite/Controls/FinOpsTab.xaml
+++ b/Lite/Controls/FinOpsTab.xaml
@@ -651,14 +651,7 @@
                     <TextBlock Text="Database Resource Usage" VerticalAlignment="Center" Margin="0,0,10,0"
                                FontWeight="Bold" FontSize="14"
                                Foreground="{DynamicResource ForegroundBrush}"/>
-                    <ComboBox x:Name="ResourceUsageTimeRangeCombo" SelectedIndex="3" Width="120" Margin="0,0,8,0"
-                              SelectionChanged="ResourceUsageTimeRange_Changed">
-                        <ComboBoxItem Content="Last 1 hour"/>
-                        <ComboBoxItem Content="Last 4 hours"/>
-                        <ComboBoxItem Content="Last 12 hours"/>
-                        <ComboBoxItem Content="Last 24 hours"/>
-                        <ComboBoxItem Content="Last 7 days"/>
-                    </ComboBox>
+                    <ui:TimeRangePicker x:Name="ResourceUsageTimeRangePicker" Compact="True" Margin="0,0,8,0" RangeChanged="ResourceUsageTimeRange_RangeChanged"/>
                     <Button Content="Refresh" Click="RefreshDatabaseResources_Click"
                             Margin="4,0,0,0" Padding="10,4" MinWidth="70"/>
                     <TextBlock x:Name="DbResourcesCountIndicator" Text="" Margin="12,0,0,0"
@@ -852,12 +845,8 @@
                     <TextBlock Text="Window:" VerticalAlignment="Center" Margin="16,0,6,0" FontSize="11"
                                x:Name="ObjectHeatmapWindowLabel" Visibility="Collapsed"
                                Foreground="{DynamicResource ForegroundMutedBrush}"/>
-                    <ComboBox x:Name="ObjectHeatmapWindowCombo" Visibility="Collapsed" SelectedIndex="1"
-                              Width="120" FontSize="11" Padding="4,2" SelectionChanged="ObjectHeatmapWindow_Changed">
-                        <ComboBoxItem Content="Last 7 days"/>
-                        <ComboBoxItem Content="Last 30 days"/>
-                        <ComboBoxItem Content="Last 90 days"/>
-                    </ComboBox>
+                    <ui:TimeRangePicker x:Name="ObjectHeatmapWindowPicker" Compact="True" Visibility="Collapsed"
+                                        RangeChanged="ObjectHeatmapWindow_RangeChanged"/>
                 </StackPanel>
 
                 <Grid Grid.Row="1" Margin="10,0,10,10">
@@ -2263,14 +2252,7 @@
                             <StackPanel Orientation="Horizontal">
                                 <TextBlock Text="Wait Stats Summary" VerticalAlignment="Center"/>
                                 <TextBlock Text="  Time Range:" VerticalAlignment="Center" Margin="12,0,4,0" FontSize="11"/>
-                                <ComboBox x:Name="WaitStatsTimeRangeCombo" SelectedIndex="3" Width="120" FontSize="11"
-                                          SelectionChanged="WaitStatsTimeRange_Changed">
-                                    <ComboBoxItem Content="Last 1 hour"/>
-                                    <ComboBoxItem Content="Last 4 hours"/>
-                                    <ComboBoxItem Content="Last 12 hours"/>
-                                    <ComboBoxItem Content="Last 24 hours"/>
-                                    <ComboBoxItem Content="Last 7 days"/>
-                                </ComboBox>
+                                <ui:TimeRangePicker x:Name="WaitStatsTimeRangePicker" Compact="True" RangeChanged="WaitStatsTimeRange_RangeChanged"/>
                             </StackPanel>
                         </Expander.Header>
                         <StackPanel>
@@ -2329,14 +2311,7 @@
                             <StackPanel Orientation="Horizontal">
                                 <TextBlock Text="Expensive Queries (Top 20 by CPU)" VerticalAlignment="Center"/>
                                 <TextBlock Text="  Time Range:" VerticalAlignment="Center" Margin="12,0,4,0" FontSize="11"/>
-                                <ComboBox x:Name="ExpensiveQueriesTimeRangeCombo" SelectedIndex="3" Width="120" FontSize="11"
-                                          SelectionChanged="ExpensiveQueriesTimeRange_Changed">
-                                    <ComboBoxItem Content="Last 1 hour"/>
-                                    <ComboBoxItem Content="Last 4 hours"/>
-                                    <ComboBoxItem Content="Last 12 hours"/>
-                                    <ComboBoxItem Content="Last 24 hours"/>
-                                    <ComboBoxItem Content="Last 7 days"/>
-                                </ComboBox>
+                                <ui:TimeRangePicker x:Name="ExpensiveQueriesTimeRangePicker" Compact="True" RangeChanged="ExpensiveQueriesTimeRange_RangeChanged"/>
                             </StackPanel>
                         </Expander.Header>
                         <StackPanel>
@@ -2486,14 +2461,7 @@
                             Margin="12,0,0,0" Padding="10,4" MinWidth="70"/>
                     <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="16,0,4,0" FontSize="11"
                                Foreground="{DynamicResource ForegroundBrush}"/>
-                    <ComboBox x:Name="HighImpactTimeRangeCombo" SelectedIndex="3" Width="120" FontSize="11"
-                              SelectionChanged="HighImpactTimeRange_Changed">
-                        <ComboBoxItem Content="Last 1 hour"/>
-                        <ComboBoxItem Content="Last 4 hours"/>
-                        <ComboBoxItem Content="Last 12 hours"/>
-                        <ComboBoxItem Content="Last 24 hours"/>
-                        <ComboBoxItem Content="Last 7 days"/>
-                    </ComboBox>
+                    <ui:TimeRangePicker x:Name="HighImpactTimeRangePicker" Compact="True" RangeChanged="HighImpactTimeRange_RangeChanged"/>
                     <TextBlock x:Name="HighImpactCountIndicator" VerticalAlignment="Center" Margin="12,0,0,0"
                                FontStyle="Italic" Foreground="{DynamicResource AccentBrush}" FontWeight="SemiBold"/>
                 </StackPanel>
diff --git a/Lite/Controls/FinOpsTab.xaml.cs b/Lite/Controls/FinOpsTab.xaml.cs
index 0affb1c2a3..b616977223 100644
--- a/Lite/Controls/FinOpsTab.xaml.cs
+++ b/Lite/Controls/FinOpsTab.xaml.cs
@@ -80,6 +80,13 @@ sites already (ServerTab.Pickers.cs' _waitStatsPickerGen / _memoryClerksPickerGe
     public FinOpsTab()
     {
         InitializeComponent();
+        /* #5562: every list opened on the last 24 hours (1d); the heatmap on 30 days (1mo). */
+        var day = TimeRangePresets.FromLegacyHours(24)!;
+        ResourceUsageTimeRangePicker.Value = day;
+        WaitStatsTimeRangePicker.Value = day;
+        ExpensiveQueriesTimeRangePicker.Value = day;
+        HighImpactTimeRangePicker.Value = day;
+        ObjectHeatmapWindowPicker.Value = TimeRangePresets.FromLegacyHours(720)!;
         InitializeFilterManagers();
         IsVisibleChanged += (_, _) => ReloadUnfinishedSizeGridsOnShow();
     }
@@ -549,9 +556,7 @@ private static void SetBar(Border bar, ColumnDefinition filled, ColumnDefinition
         empty.Width = new GridLength(Math.Max(100 - clamped, 0.1), GridUnitType.Star);
     }
 
-    private int HoursBackFromIndex(System.Windows.Controls.ComboBox combo) => combo.SelectedIndex switch { 0 => 1, 1 => 4, 2 => 12, 3 => 24, 4 => 168, _ => 24 };
-
-    private async void ResourceUsageTimeRange_Changed(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
+    private async void ResourceUsageTimeRange_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded || _dataService == null) return;
         var serverId = GetSelectedServerId();
@@ -566,7 +571,7 @@ private async System.Threading.Tasks.Task LoadDatabaseResourcesAsync(int serverI
 
         try
         {
-            var hoursBack = HoursBackFromIndex(ResourceUsageTimeRangeCombo);
+            var hoursBack = LiteTimeRange.HoursBackOf(ResourceUsageTimeRangePicker, 24);
             var data = await Task.Run(() => _dataService.GetDatabaseResourceUsageAsync(serverId, hoursBack));
             if (_loads.Superseded(nameof(LoadDatabaseResourcesAsync), gen)) return;
             _dbResourcesFilterMgr!.UpdateData(data);
@@ -957,7 +962,7 @@ private async System.Threading.Tasks.Task LoadHighImpactQueriesAsync(int serverI
 
         try
         {
-            var hoursBack = HoursBackFromIndex(HighImpactTimeRangeCombo);
+            var hoursBack = LiteTimeRange.HoursBackOf(HighImpactTimeRangePicker, 24);
             var data = await Task.Run(() => _dataService.GetHighImpactQueriesAsync(serverId, hoursBack));
             if (_loads.Superseded(nameof(LoadHighImpactQueriesAsync), gen)) return;
             _highImpactFilterMgr!.UpdateData(data);
@@ -977,7 +982,7 @@ private async System.Threading.Tasks.Task LoadWaitCategorySummaryAsync(int serve
 
         try
         {
-            var hoursBack = HoursBackFromIndex(WaitStatsTimeRangeCombo);
+            var hoursBack = LiteTimeRange.HoursBackOf(WaitStatsTimeRangePicker, 24);
             var data = await Task.Run(() => _dataService.GetWaitCategorySummaryAsync(serverId, hoursBack));
             if (_loads.Superseded(nameof(LoadWaitCategorySummaryAsync), gen)) return;
 
@@ -1009,7 +1014,7 @@ private async System.Threading.Tasks.Task LoadExpensiveQueriesAsync(int serverId
 
         try
         {
-            var hoursBack = HoursBackFromIndex(ExpensiveQueriesTimeRangeCombo);
+            var hoursBack = LiteTimeRange.HoursBackOf(ExpensiveQueriesTimeRangePicker, 24);
             var data = await Task.Run(() => _dataService.GetExpensiveQueriesAsync(serverId, hoursBack));
             if (_loads.Superseded(nameof(LoadExpensiveQueriesAsync), gen)) return;
 
@@ -1135,7 +1140,7 @@ private async void RefreshStorageGrowth_Click(object sender, RoutedEventArgs e)
         }
     }
 
-    private async void WaitStatsTimeRange_Changed(object sender, SelectionChangedEventArgs e)
+    private async void WaitStatsTimeRange_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded || _dataService == null) return;
         var serverId = GetSelectedServerId();
@@ -1143,7 +1148,7 @@ private async void WaitStatsTimeRange_Changed(object sender, SelectionChangedEve
         await LoadWaitCategorySummaryAsync(serverId);
     }
 
-    private async void ExpensiveQueriesTimeRange_Changed(object sender, SelectionChangedEventArgs e)
+    private async void ExpensiveQueriesTimeRange_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded || _dataService == null) return;
         var serverId = GetSelectedServerId();
@@ -1157,7 +1162,7 @@ private async void RefreshHighImpact_Click(object sender, RoutedEventArgs e)
         if (serverId != 0) await LoadHighImpactQueriesAsync(serverId);
     }
 
-    private async void HighImpactTimeRange_Changed(object sender, SelectionChangedEventArgs e)
+    private async void HighImpactTimeRange_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded || _dataService == null) return;
         var serverId = GetSelectedServerId();
diff --git a/Lite/Controls/JobHistoryTab.xaml b/Lite/Controls/JobHistoryTab.xaml
index 7f4b95e096..47e63ee9e2 100644
--- a/Lite/Controls/JobHistoryTab.xaml
+++ b/Lite/Controls/JobHistoryTab.xaml
@@ -1,6 +1,7 @@
 <UserControl x:Class="PerformanceMonitorLite.Controls.JobHistoryTab"
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:ui="clr-namespace:PerformanceMonitor.Ui;assembly=PerformanceMonitor.Ui"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              mc:Ignorable="d"
@@ -65,14 +66,7 @@
                        Foreground="{DynamicResource ForegroundBrush}"/>
             <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="5,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
-            <ComboBox x:Name="TimeRangeComboBox" Width="100" VerticalAlignment="Center"
-                      SelectionChanged="Filter_SelectionChanged">
-                <ComboBoxItem Content="Last 24 Hours" Tag="24" IsSelected="True"/>
-                <ComboBoxItem Content="Last 7 Days" Tag="168"/>
-                <ComboBoxItem Content="Last 30 Days" Tag="720"/>
-                <ComboBoxItem Content="Last 90 Days" Tag="2160"/>
-                <ComboBoxItem Content="Last Year" Tag="8760"/>
-            </ComboBox>
+            <ui:TimeRangePicker x:Name="RangePicker" VerticalAlignment="Center" RangeChanged="RangePicker_RangeChanged"/>
             <TextBlock Text="Server:" VerticalAlignment="Center" Margin="12,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
             <ComboBox x:Name="ServerFilterComboBox" Width="150" VerticalAlignment="Center"
diff --git a/Lite/Controls/JobHistoryTab.xaml.cs b/Lite/Controls/JobHistoryTab.xaml.cs
index 6c1bb04617..011c1fd592 100644
--- a/Lite/Controls/JobHistoryTab.xaml.cs
+++ b/Lite/Controls/JobHistoryTab.xaml.cs
@@ -43,6 +43,7 @@ public partial class JobHistoryTab : UserControl
     public JobHistoryTab()
     {
         InitializeComponent();
+        RangePicker.Value = TimeRangePresets.FromLegacyHours(24)!; /* 24 hours, as the list opened; '1mo' is the old 30 days, '90d' or '1y' can be typed */
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
@@ -417,9 +418,7 @@ private void PopulateCategoryFilter(List<JobHistoryRow> rows)
 
     private int GetSelectedHoursBack()
     {
-        if (TimeRangeComboBox.SelectedItem is ComboBoxItem item && item.Tag is string tagStr)
-            return int.TryParse(tagStr, out var hours) ? hours : 24;
-        return 24;
+        return LiteTimeRange.HoursBackOf(RangePicker, 24);
     }
 
     private int? GetSelectedServerId()
@@ -543,6 +542,12 @@ private async void Filter_SelectionChanged(object sender, SelectionChangedEventA
             await LoadJobsAsync();
     }
 
+    private async void RangePicker_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
+    {
+        if (IsLoaded)
+            await LoadJobsAsync();
+    }
+
     private async void RefreshButton_Click(object sender, RoutedEventArgs e)
     {
         await LoadJobsAsync();
diff --git a/Lite/Controls/ServerTab.DrillDown.cs b/Lite/Controls/ServerTab.DrillDown.cs
index 50b7e8aa8d..d4f6f95023 100644
--- a/Lite/Controls/ServerTab.DrillDown.cs
+++ b/Lite/Controls/ServerTab.DrillDown.cs
@@ -204,30 +204,21 @@ private async void OnHeatmapDrillDown(DateTime bucketTimeUtc)
     }
 
     /// <summary>
-    /// Sets the time range combo to Custom and populates the date/time pickers
+    /// Holds the drilled window as the toolbar's range (a fixed range on the picker)
     /// so the user can navigate other tabs at the same time window.
     /// </summary>
     private void SetDrillDownTimeRange(DateTime fromUtc, DateTime toUtc)
     {
-        /* The drill's window is held as the instants it names (#4766) and the pickers show it in the display zone. */
-        _customRange.Set(fromUtc, toUtc);
+        /* The drill's window is held as the instants it names (#4766, #5562): a fixed range, which the picker shows in the
+           display zone. The model refuses anything under 5 minutes, so a narrower drill is centred and held at 5 minutes
+           (the drilled grid itself still reads the exact pair it was handed). */
+        (fromUtc, toUtc) = LiteTimeRange.AtLeastMinimumSpan(fromUtc, toUtc);
 
-        // Switch to Custom without triggering a refresh
+        // Hold it without triggering a refresh (Value raises no RangeChanged; the flag covers a handler that might)
         _suppressRangeRefresh = true;
         try
         {
-            TimeRangeCombo.SelectedIndex = 5; // Custom
-            RenderCustomRange();
-
-            // Make pickers visible
-            var visibility = Visibility.Visible;
-            FromDatePicker.Visibility = visibility;
-            FromHourCombo.Visibility = visibility;
-            FromMinuteCombo.Visibility = visibility;
-            ToLabel.Visibility = visibility;
-            ToDatePicker.Visibility = visibility;
-            ToHourCombo.Visibility = visibility;
-            ToMinuteCombo.Visibility = visibility;
+            RangePicker.Value = TimeRangeSpec.FixedRange(fromUtc, toUtc);
         }
         finally
         {
diff --git a/Lite/Controls/ServerTab.Refresh.cs b/Lite/Controls/ServerTab.Refresh.cs
index faa626bf48..00e77fe2f2 100644
--- a/Lite/Controls/ServerTab.Refresh.cs
+++ b/Lite/Controls/ServerTab.Refresh.cs
@@ -60,19 +60,15 @@ the global database filter is applied client-side on the parsed per-process rows
     /// <summary>
     /// The current toolbar window as (hoursBack, fromUtc, toUtc) -- the single derivation shared by the data refresh and
     /// the per-chart Revert / double-click axis re-pin, so both read the same window. A preset leaves from/to null
-    /// (charts fall back to now - hoursBack); a custom range is the pair of naive-UTC instants the tab holds
-    /// (#4766), handed to every read as it is: no clock takes part, so the read, the slicer and the alert badge all
-    /// see the same two instants whichever display zone the pickers show.
+    /// (charts fall back to now - hoursBack); any other range (a calendar period, a sub-hour span, a typed or
+    /// picked range, 'since') is the pair of naive-UTC instants it resolves to (#4766, #5562), handed to every read as
+    /// it is: no clock takes part, so the read, the slicer and the alert badge all see the same two instants whichever
+    /// display zone the picker shows. A fixed range holds its instants itself, so a display-mode switch changes only the text.
     /// </summary>
     private (int hoursBack, DateTime? fromUtc, DateTime? toUtc) GetCurrentWindowUtc()
     {
-        /* A range the pickers show but the tab has not yet held (their defaults, filled before any edit) is taken from them once. */
-        if (IsCustomRange && !_customRange.IsCustom)
-        {
-            CaptureCustomRangeEdit(null);
-        }
-
-        return CurrentWindowUtc(GetHoursBack(), IsCustomRange, _customRange);
+        /* #5562: resolved against the clock now, so a live range slides; the one pure mapping is LiteTimeRange.WindowFor. */
+        return LiteTimeRange.WindowFor(CurrentRange());
     }
 
     /// <summary>
@@ -156,6 +152,10 @@ private Task RefreshVisibleTabOnlyAsync()
 
     private async Task RunRefreshPassAsync(RefreshScope scope, CancellationToken ct)
     {
+        /* #5562: a live range slides and the collector's cadence can be edited, so the picker's text and notes are
+           redrawn at the start of every pass. */
+        RefreshRangeNotes();
+
         if (scope == RefreshScope.VisibleTab)
         {
             /* The window and the selected tab are read now, at the pass's own start, so a replay loads whatever is
@@ -183,8 +183,8 @@ so the flag cannot be left set by a failed clock read or picker render. */
             if (ct.IsCancellationRequested) return;
 
             /* The server's zone can change under the held range (its clock was just read again, or another tab switched
-               the display mode), so the pickers are shown again from the held instants before the window is read. */
-            RenderCustomRange();
+               the display mode), so the picker is drawn again in the current zone before the window is read. */
+            RangePicker.Refresh();
 
             /* The window is the held range as UTC instants (#4766): every read below takes the same two instants. */
             var (hoursBack, fromDate, toDate) = GetCurrentWindowUtc();
@@ -611,6 +611,13 @@ private async System.Threading.Tasks.Task RefreshWindowTruncatedBannerAsync(Quer
             () => Task.Run(() => _dataService.GetQueryWindowFloorAsync(relation, _serverId, startUtc, endUtc, includeAlsoCovered: includeAlsoCovered, cancellationToken: ct)),
             $"[{_server.DisplayName}] {relation}", startUtc, endUtc, ct);
         ApplyWindowFloorToBanner(banner, EarlierOfFloorAndRowShown(floor, earliestRowShownUtc), startUtc, GetPickerZone());
+
+        /* #5562: the picker's 'Data starts ...' note takes its start from the probe this tab already awaited (the Queries
+           grid's, the primary surface), else the archive's static retention edge. No new query. */
+        if (relation == QueryWindowRelation.QueryStats)
+        {
+            RangePicker.DataStartUtc = LiteTimeRange.DataStartFor(floor, DateTime.UtcNow);
+        }
     }
 
     /// <summary>
diff --git a/Lite/Controls/ServerTab.TimeRange.cs b/Lite/Controls/ServerTab.TimeRange.cs
index e3f2b91c3b..bf7ec6c258 100644
--- a/Lite/Controls/ServerTab.TimeRange.cs
+++ b/Lite/Controls/ServerTab.TimeRange.cs
@@ -36,68 +36,62 @@ namespace PerformanceMonitorLite.Controls;
 
 public partial class ServerTab : UserControl
 {
-    private void InitializeTimeComboBoxes()
+    /// <summary>
+    /// The range the toolbar picker holds, resolved against the clock now (#5562). A live range (the last 5 minutes,
+    /// 'Today', 'since ...') slides with every call. When the held range cannot be used at this moment ('Today' in the
+    /// first minutes after midnight is under the 5-minute floor) the last window that did resolve keeps being read, so
+    /// a refresh never reads nothing; with none yet, the default of four hours.
+    /// </summary>
+    private ResolvedTimeRange CurrentRange()
     {
-        // Populate hour ComboBoxes (12-hour format with AM/PM)
-        var hours = new List<string>();
-        for (int h = 0; h < 24; h++)
+        if (RangePicker.Resolve() is { } resolved)
+        {
+            _lastResolvedRange = resolved;
+            return resolved;
+        }
+
+        if (_lastResolvedRange != null)
         {
-            var dt = DateTime.Today.AddHours(h);
-            hours.Add(dt.ToString("HH:00")); // "00:00", "01:00", ..., "23:00"
+            return _lastResolvedRange;
         }
 
-        FromHourCombo.ItemsSource = hours;
-        ToHourCombo.ItemsSource = hours;
-        FromHourCombo.SelectedIndex = 0;  // Default to 12 AM
-        ToHourCombo.SelectedIndex = 23;   // Default to 11 PM
-
-        // Populate minute ComboBoxes (15-minute intervals)
-        var minutes = new List<string> { ":00", ":15", ":30", ":45" };
-        FromMinuteCombo.ItemsSource = minutes;
-        ToMinuteCombo.ItemsSource = minutes;
-        FromMinuteCombo.SelectedIndex = 0; // Default to :00
-        ToMinuteCombo.SelectedIndex = 3;   // Default to :45 (so 11:45 PM is end)
+        LiteTimeRange.Default.TryResolve(DateTime.UtcNow, GetPickerZone(), out var fallback, out _);
+        return fallback!;
     }
 
-    private DateTime? GetDateTimeFromPickers(DatePicker datePicker, ComboBox hourCombo, ComboBox minuteCombo)
-    {
-        if (!datePicker.SelectedDate.HasValue) return null;
+    private ResolvedTimeRange? _lastResolvedRange;
 
-        var date = datePicker.SelectedDate.Value.Date;
-        int hour = hourCombo.SelectedIndex >= 0 ? hourCombo.SelectedIndex : 0;
-        int minute = minuteCombo.SelectedIndex >= 0 ? minuteCombo.SelectedIndex * 15 : 0;
+    /// <summary>
+    /// How often this tab's main collector samples, read from the schedule when asked (#5562, ruling R3): the picker shows
+    /// 'Data here is collected every N minutes.' when a span holds fewer than 3 samples. Set by MainWindow, which owns the
+    /// schedule; a tab opened without one (a test) shows no note.
+    /// </summary>
+    private Func<TimeSpan?>? _sampleIntervalProvider;
 
-        return date.AddHours(hour).AddMinutes(minute);
+    /// <summary>The collector whose cadence the picker's note names: the 1-minute wait stats sample behind the tab's charts.</summary>
+    internal const string MainCollectorName = "wait_stats";
+
+    /// <summary>Hands the tab the way to read its main collector's actual interval (<see cref="MainCollectorName"/>).</summary>
+    public void SetSampleIntervalSource(Func<TimeSpan?> provider)
+    {
+        _sampleIntervalProvider = provider;
+        RefreshRangeNotes();
     }
 
-    /// <summary>
-    /// Gets the selected time range in hours.
-    /// </summary>
-    private int GetHoursBack()
+    /// <summary>Redraws the picker's resolved text and its sample-interval note (a live range slides; the schedule can be edited).</summary>
+    private void RefreshRangeNotes()
     {
-        return TimeRangeCombo.SelectedIndex switch
-        {
-            0 => 1,
-            1 => 4,
-            2 => 12,
-            3 => 24,
-            4 => 168,
-            _ => 4
-        };
+        RangePicker.SampleInterval = _sampleIntervalProvider?.Invoke();
+        RangePicker.Refresh();
     }
 
     /// <summary>
-    /// The custom range this tab holds (#4766): two naive-UTC instants, or nothing until one is chosen. The pickers on
-    /// the toolbar are a rendering of it in the display zone (<see cref="RenderCustomRange"/>), not the state: every
-    /// read, slicer, drill and chart window takes its instants from here (<see cref="GetCurrentWindowUtc"/>), and only
-    /// a change the user makes to a picker parses text back into an instant (<see cref="CaptureCustomRangeEdit"/>).
-    /// A display-mode switch therefore changes the text on the pickers and nothing else, and a range in the hour that
-    /// repeats after a fall-back keeps the occurrence it was made for.
+    /// Hours back from now that cover the range (#5562): the preset's own hours for a whole-hour rolling range, else the
+    /// whole hours from the range's start to now rounded up (at least 1), so a reader that only takes hours back (a
+    /// history window opened from a row) still covers a 15-minute span or a calendar period. Readers that carry
+    /// instants take them from <see cref="GetCurrentWindowUtc"/>.
     /// </summary>
-    private readonly CustomRangeState _customRange = new();
-
-    /// <summary>True while the pickers are written from <see cref="_customRange"/>, so those writes are not read as the user typing.</summary>
-    private bool _renderingCustomRange;
+    private int GetHoursBack() => LiteTimeRange.WindowFor(CurrentRange()).hoursBack;
 
     /// <summary>
     /// True during a synchronous, programmatic write to the range controls (a display-mode switch re-rendering the pickers,
@@ -115,75 +109,8 @@ private int GetHoursBack()
     internal static TimeZoneInfo PickerZone(TimeDisplayMode mode, ServerClock tabClock) =>
         ServerTimeHelper.DisplayZoneFor(mode, tabClock);
 
-    /// <summary>
-    /// The window a refresh reads, as (hoursBack, fromUtc, toUtc): the held custom range when a custom range is
-    /// selected and one is held, else the preset with no bounds. Pure, so a test drives it without the control.
-    /// </summary>
-    internal static (int hoursBack, DateTime? fromUtc, DateTime? toUtc) CurrentWindowUtc(
-        int hoursBack, bool customSelected, CustomRangeState held) =>
-        customSelected && held.IsCustom ? (hoursBack, held.FromUtc, held.ToUtc) : (hoursBack, null, null);
-
     private TimeZoneInfo GetPickerZone() => PickerZone(ServerTimeHelper.CurrentDisplayMode, _serverClock);
 
-    private bool IsFromPicker(object? sender) =>
-        ReferenceEquals(sender, FromDatePicker) || ReferenceEquals(sender, FromHourCombo) || ReferenceEquals(sender, FromMinuteCombo);
-
-    /// <summary>
-    /// A typed edit (#4766): the picker the user changed is read as a wall clock in the display zone and becomes that
-    /// side of the held range; the other side keeps its exact instant. With nothing held yet (the pickers were filled
-    /// before any edit) both pickers are read once and the pair is held. Reads the pickers, so it is the only place
-    /// their text is parsed.
-    /// </summary>
-    private void CaptureCustomRangeEdit(object? sender)
-    {
-        var fromWall = GetDateTimeFromPickers(FromDatePicker!, FromHourCombo, FromMinuteCombo);
-        var toWall = GetDateTimeFromPickers(ToDatePicker!, ToHourCombo, ToMinuteCombo);
-        var zone = GetPickerZone();
-        if (_customRange.IsCustom)
-        {
-            var fromSide = IsFromPicker(sender);
-            var wall = fromSide ? fromWall : toWall;
-            if (wall.HasValue)
-            {
-                _customRange.ApplyEdit(wall.Value, fromSide ? BoundSide.From : BoundSide.To, zone);
-            }
-        }
-        else if (fromWall.HasValue && toWall.HasValue)
-        {
-            _customRange.Set(
-                DisplayZone.ToUtcBound(fromWall.Value, zone, BoundSide.From),
-                DisplayZone.ToUtcBound(toWall.Value, zone, BoundSide.To));
-        }
-    }
-
-    /// <summary>
-    /// Shows the held range on the pickers in the display zone (#4766). Each bound is rendered as its own instant, so a
-    /// switch of zone changes only the text; nothing is parsed back. The picker minutes step in quarter hours, so an
-    /// instant between two steps shows the step below it while the held instant stays exact.
-    /// </summary>
-    private void RenderCustomRange()
-    {
-        if (_customRange.Render(GetPickerZone()) is not { } shown)
-        {
-            return;
-        }
-
-        _renderingCustomRange = true;
-        try
-        {
-            FromDatePicker.SelectedDate = shown.From.Date;
-            FromHourCombo.SelectedIndex = shown.From.Hour;
-            FromMinuteCombo.SelectedIndex = shown.From.Minute / 15;
-            ToDatePicker.SelectedDate = shown.To.Date;
-            ToHourCombo.SelectedIndex = shown.To.Hour;
-            ToMinuteCombo.SelectedIndex = shown.To.Minute / 15;
-        }
-        finally
-        {
-            _renderingCustomRange = false;
-        }
-    }
-
     /// <summary>
     /// The chart axis window as UTC instants (#4766), the frame every chart on this tab plots in: the custom range
     /// when one is set, else the last <paramref name="hoursBack"/> real hours ending now
@@ -202,19 +129,14 @@ internal static (DateTime Start, DateTime End) GetChartWindow(
         GetChartWindow(hoursBack, fromDate, toDate, DateTime.UtcNow);
 
     /// <summary>
-    /// Sets the time range dropdown from outside (used by Apply to All).
+    /// Holds <paramref name="spec"/> on this tab as if the user picked it (used by Apply to All): the picker redraws, and its
+    /// RangeChanged handler persists the choice and refreshes. A range this tab cannot use right now is left as it was.
     /// </summary>
-    public void SetTimeRangeIndex(int index)
-    {
-        if (index >= 0 && index < TimeRangeCombo.Items.Count)
-        {
-            TimeRangeCombo.SelectedIndex = index;
-        }
-    }
+    public void SetTimeRange(TimeRangeSpec spec) => RangePicker.Select(spec);
 
     private void ApplyTimeRangeToAll_Click(object sender, RoutedEventArgs e)
     {
-        ApplyTimeRangeRequested?.Invoke(TimeRangeCombo.SelectedIndex);
+        ApplyTimeRangeRequested?.Invoke(RangePicker.Value);
     }
 
     /* The _refreshTimer null guard in both handlers below is doing two jobs. It always absorbed the
@@ -347,7 +269,7 @@ private async void TimeDisplayMode_SelectionChanged(object sender, SelectionChan
         try
         {
             ServerTimeHelper.CurrentDisplayMode = mode;
-            RenderCustomRange();
+            RangePicker.Refresh();
         }
         finally
         {
@@ -381,200 +303,44 @@ refresh a range change does — the Viewer's toggle ends with RefreshActiveInner
         await RefreshAllDataAsync();
     }
 
-    private async void TimeRangeCombo_SelectionChanged(object sender, SelectionChangedEventArgs e)
+    /// <summary>
+    /// The picker's choice (a preset, a calendar period, a typed range or a picked day). Remembers it
+    /// (<see cref="PersistSelectedTimeRange"/>) and re-reads every grid and chart. A programmatic write that must not
+    /// refresh sets <c>_suppressRangeRefresh</c>; an in-flight refresh is the coordinator's to replay (#5371), so this
+    /// does not look at <c>_isRefreshing</c>.
+    ///
+    /// <para>#2640: before the choice was remembered the control was write-only: the setting existed and was read at
+    /// startup, but only the Settings window wrote it, so choosing a longer range here and restarting came back at four
+    /// hours. A typed range is deliberately NOT persisted: restoring a window that ended two days ago would show an
+    /// empty chart of a range the operator has moved on from.</para>
+    /// </summary>
+    private async void RangePicker_RangeChanged(object? sender, TimeRangeChangedEventArgs e)
     {
         if (!IsLoaded || _suppressRangeRefresh) return;
 
-        /* Show/hide custom date pickers and time ComboBoxes */
-        var isCustom = TimeRangeCombo.SelectedIndex == 5;
-        var visibility = isCustom ? Visibility.Visible : Visibility.Collapsed;
-
-        if (FromDatePicker != null)
-        {
-            FromDatePicker.Visibility = visibility;
-            FromHourCombo.Visibility = visibility;
-            FromMinuteCombo.Visibility = visibility;
-            ToLabel.Visibility = visibility;
-            ToDatePicker.Visibility = visibility;
-            ToHourCombo.Visibility = visibility;
-            ToMinuteCombo.Visibility = visibility;
-
-            if (isCustom && FromDatePicker.SelectedDate == null)
-            {
-                FromDatePicker.SelectedDate = DateTime.Today.AddDays(-1);
-                ToDatePicker.SelectedDate = DateTime.Today;
-            }
-
-            if (!isCustom)
-            {
-                /* #2154: a DatePicker's calendar dropdown is a POPUP, which lives outside the visual
-                   tree's visibility — collapsing the picker does not close an already-open dropdown,
-                   so backing out of Custom Range without picking a date left an orphaned floating
-                   calendar on screen. Close them explicitly alongside the collapse. */
-                FromDatePicker.IsDropDownOpen = false;
-                ToDatePicker.IsDropDownOpen = false;
-            }
-        }
-
-        if (!isCustom)
-        {
-            /* #2640: remember the choice. Before this the picker was write-only — the settings key
-               default_time_range_hours existed and was read at startup, but the only thing that wrote it
-               was the Settings window, so choosing "Last 7 days" here and restarting came back at four
-               hours with nothing to explain why. A control that offers a choice and discards it reads as
-               broken, and the reporter read it that way.
-
-               Custom Range is deliberately NOT persisted: it has no hours value to store, and restoring a
-               window that ended two days ago would be worse than restoring nothing — the app would open
-               showing an empty chart of a range the operator has moved on from. */
-            PersistSelectedTimeRange();
+        PersistSelectedTimeRange(e.Spec);
 
-            await RefreshAllDataAsync();
-        }
+        await RefreshAllDataAsync();
     }
 
     /// <summary>
-    /// Writes the picked range to <c>default_time_range_hours</c>, the same key the Settings window writes
-    /// and startup reads, so the two cannot disagree about what the range means. Failure is logged by
-    /// <see cref="App.WriteSetting"/> and never interrupts the refresh — a settings file that cannot be
-    /// written must not stop the user looking at data.
+    /// Writes the picked range to settings.json, the same keys the Settings window writes and startup reads
+    /// (<see cref="LiteTimeRange.SettingsFor"/>): a whole-hour rolling range to the legacy <c>default_time_range_hours</c>
+    /// (older builds read it), any other preset or calendar period to <c>default_time_range</c>. A typed range writes
+    /// nothing. Failure is logged by <see cref="App.WriteSetting"/> and never interrupts the refresh.
     /// </summary>
-    private void PersistSelectedTimeRange()
+    private void PersistSelectedTimeRange(TimeRangeSpec spec)
     {
-        var hours = TimeRangeCombo.SelectedIndex switch
-        {
-            0 => 1,
-            1 => 4,
-            2 => 12,
-            3 => 24,
-            4 => 168,
-            _ => 0,
-        };
-
-        if (hours == 0)
+        var (rangeId, hours) = LiteTimeRange.SettingsFor(spec);
+        if (rangeId == null && hours == null)
         {
             return;
         }
 
-        /* The in-memory value too, not only the file: a second server tab opened in this same session
-           reads App.DefaultTimeRangeHours in its constructor, and a tab that opens on a different range
-           from the one just chosen is the same complaint in a smaller window. */
-        App.DefaultTimeRangeHours = hours;
-
-        App.WriteSetting("time range", root => root["default_time_range_hours"] = hours);
-    }
-
-    private async void CustomDateRange_Changed(object sender, SelectionChangedEventArgs e)
-    {
-        if (!IsLoaded || _renderingCustomRange) return;
-        CaptureCustomRangeEdit(sender);
-        /* #5371: a picker edit that lands while a refresh is in flight is kept (captured above) and refreshed when that
-           one ends; only a programmatic write is skipped. */
-        if (_suppressRangeRefresh) return;
-        if (FromDatePicker?.SelectedDate != null && ToDatePicker?.SelectedDate != null)
-        {
-            await RefreshAllDataAsync();
-        }
-    }
-
-    private async void CustomTimeCombo_Changed(object sender, SelectionChangedEventArgs e)
-    {
-        if (!IsLoaded || _renderingCustomRange) return;
-        CaptureCustomRangeEdit(sender);
-        if (_suppressRangeRefresh) return;
-        /* Only refresh if we have valid dates selected */
-        if (FromDatePicker?.SelectedDate != null && ToDatePicker?.SelectedDate != null)
-        {
-            await RefreshAllDataAsync();
-        }
-    }
+        /* The in-memory values too, not only the file: a second server tab opened in this same session reads them in its
+           constructor, and a tab that opens on a different range from the one just chosen is the same complaint. */
+        App.ApplyDefaultTimeRange(rangeId, hours);
 
-    private void DatePicker_CalendarOpened(object sender, RoutedEventArgs e)
-    {
-        if (sender is DatePicker datePicker)
-        {
-            /* Use Dispatcher to ensure visual tree is ready */
-            Dispatcher.BeginInvoke(new Action(() =>
-            {
-                var popup = datePicker.Template.FindName("PART_Popup", datePicker) as System.Windows.Controls.Primitives.Popup;
-                if (popup?.Child is System.Windows.Controls.Calendar calendar)
-                {
-                    ApplyThemeToCalendar(calendar);
-                }
-            }));
-        }
-    }
-
-    private void ApplyThemeToCalendar(System.Windows.Controls.Calendar calendar)
-    {
-        SolidColorBrush primaryBg, fg, borderBrush;
-
-        if (ThemeManager.CurrentTheme == "CoolBreeze")
-        {
-            primaryBg   = new SolidColorBrush((System.Windows.Media.Color)ColorConverter.ConvertFromString("#EEF4FA")!);
-            fg          = new SolidColorBrush((System.Windows.Media.Color)ColorConverter.ConvertFromString("#1A2A3A")!);
-            borderBrush = new SolidColorBrush((System.Windows.Media.Color)ColorConverter.ConvertFromString("#A8BDD0")!);
-        }
-        else if (ThemeManager.HasLightBackground)
-        {
-            primaryBg   = new SolidColorBrush(System.Windows.Media.Color.FromRgb(0xFF, 0xFF, 0xFF));
-            fg          = new SolidColorBrush(System.Windows.Media.Color.FromRgb(0x1A, 0x1D, 0x23));
-            borderBrush = new SolidColorBrush(System.Windows.Media.Color.FromRgb(0xDE, 0xE2, 0xE6));
-        }
-        else
-        {
-            primaryBg   = new SolidColorBrush((System.Windows.Media.Color)ColorConverter.ConvertFromString("#111217")!);
-            fg          = new SolidColorBrush((System.Windows.Media.Color)ColorConverter.ConvertFromString("#E4E6EB")!);
-            borderBrush = new SolidColorBrush((System.Windows.Media.Color)ColorConverter.ConvertFromString("#2a2d35")!);
-        }
-
-        calendar.Background = primaryBg;
-        calendar.Foreground = fg;
-        calendar.BorderBrush = borderBrush;
-
-        ApplyThemeRecursively(calendar, primaryBg, fg);
-    }
-
-    private void ApplyThemeRecursively(DependencyObject parent, Brush primaryBg, Brush fg)
-    {
-        bool HasLightBackground = ThemeManager.HasLightBackground;
-        for (int i = 0; i < VisualTreeHelper.GetChildrenCount(parent); i++)
-        {
-            var child = VisualTreeHelper.GetChild(parent, i);
-
-            if (child is System.Windows.Controls.Primitives.CalendarItem calendarItem)
-            {
-                calendarItem.Background = primaryBg;
-                calendarItem.Foreground = fg;
-            }
-            else if (child is System.Windows.Controls.Primitives.CalendarDayButton dayButton)
-            {
-                dayButton.Background = Brushes.Transparent;
-                dayButton.Foreground = fg;
-            }
-            else if (child is System.Windows.Controls.Primitives.CalendarButton calButton)
-            {
-                calButton.Background = Brushes.Transparent;
-                calButton.Foreground = fg;
-            }
-            else if (child is Button button)
-            {
-                button.Background = Brushes.Transparent;
-                button.Foreground = fg;
-            }
-            else if (child is TextBlock textBlock)
-            {
-                textBlock.Foreground = fg;
-            }
-            else if (!HasLightBackground)
-            {
-                if (child is Border border && border.Background is SolidColorBrush bg && bg.Color.R > 200 && bg.Color.G > 200 && bg.Color.B > 200)
-                    border.Background = primaryBg;
-                else if (child is Grid grid && grid.Background is SolidColorBrush gridBg && gridBg.Color.R > 200 && gridBg.Color.G > 200 && gridBg.Color.B > 200)
-                    grid.Background = primaryBg;
-            }
-
-            ApplyThemeRecursively(child, primaryBg, fg);
-        }
+        App.WriteSetting("time range", root => App.WriteDefaultTimeRange(root, rangeId, hours));
     }
 }
diff --git a/Lite/Controls/ServerTab.xaml b/Lite/Controls/ServerTab.xaml
index 3e9822e72d..2c04440874 100644
--- a/Lite/Controls/ServerTab.xaml
+++ b/Lite/Controls/ServerTab.xaml
@@ -207,29 +207,9 @@
                             </Grid>
                         </Border>
                     </Popup>
-                    <ComboBox x:Name="TimeRangeCombo" SelectedIndex="1" Width="120" Margin="0,0,8,0"
-                              SelectionChanged="TimeRangeCombo_SelectionChanged">
-                        <ComboBoxItem Content="Last 1 hour"/>
-                        <ComboBoxItem Content="Last 4 hours"/>
-                        <ComboBoxItem Content="Last 12 hours"/>
-                        <ComboBoxItem Content="Last 24 hours"/>
-                        <ComboBoxItem Content="Last 7 days"/>
-                        <ComboBoxItem Content="Custom Range"/>
-                    </ComboBox>
-                    <DatePicker x:Name="FromDatePicker" Width="120" Margin="4,0,0,0" Visibility="Collapsed"
-                                SelectedDateChanged="CustomDateRange_Changed" CalendarOpened="DatePicker_CalendarOpened"/>
-                    <ComboBox x:Name="FromHourCombo" Width="70" Margin="2,0,0,0" Visibility="Collapsed"
-                              SelectionChanged="CustomTimeCombo_Changed" ToolTip="Hour"/>
-                    <ComboBox x:Name="FromMinuteCombo" Width="52" Margin="2,0,0,0" Visibility="Collapsed"
-                              SelectionChanged="CustomTimeCombo_Changed" ToolTip="Minute"/>
-                    <TextBlock x:Name="ToLabel" Text="to" VerticalAlignment="Center" Margin="6,0" Visibility="Collapsed"
-                               Foreground="{DynamicResource ForegroundBrush}"/>
-                    <DatePicker x:Name="ToDatePicker" Width="120" Margin="0,0,0,0" Visibility="Collapsed"
-                                SelectedDateChanged="CustomDateRange_Changed" CalendarOpened="DatePicker_CalendarOpened"/>
-                    <ComboBox x:Name="ToHourCombo" Width="70" Margin="2,0,0,0" Visibility="Collapsed"
-                              SelectionChanged="CustomTimeCombo_Changed" ToolTip="Hour"/>
-                    <ComboBox x:Name="ToMinuteCombo" Width="52" Margin="2,0,4,0" Visibility="Collapsed"
-                              SelectionChanged="CustomTimeCombo_Changed" ToolTip="Minute"/>
+                    <!-- #5562: the shared picker replaces the preset combo and the From/To date, hour and minute pickers. -->
+                    <ui:TimeRangePicker x:Name="RangePicker" Margin="0,0,8,0" VerticalAlignment="Center"
+                                        RangeChanged="RangePicker_RangeChanged"/>
                     <Button Content="Apply to All" Click="ApplyTimeRangeToAll_Click" Padding="8,4" Margin="0,0,8,0"
                             ToolTip="Apply this time range to all open server tabs"/>
                     <TextBlock Text="Compare:" VerticalAlignment="Center" Margin="0,0,4,0"
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 6f5b4a7919..2232aaf577 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -168,7 +168,7 @@ each refresh so toggling it in the schedule editor updates the banner without re
     /// Raised after each data refresh with alert counts for tab badge display.
     /// </summary>
     public event Action<int, int, DateTime?>? AlertCountsChanged; /* blockingCount, deadlockCount, latestEventTimeUtc */
-    public event Action<int>? ApplyTimeRangeRequested; /* selectedIndex */
+    public event Action<TimeRangeSpec>? ApplyTimeRangeRequested; /* the range to hold on the other tabs (#5562) */
     public event Func<Task>? ManualRefreshRequested;
     public event Action<ServerConnection>? PersistServerRequested; /* #1319: persist ViewFilterDatabases via ServerManager */
 
@@ -196,15 +196,13 @@ public ServerTab(ServerConnection server, DuckDbInitializer duckDb, CredentialRe
         ConnectionStatusText.Text = "Connecting...";
 
         /* Apply default time range from settings */
-        TimeRangeCombo.SelectedIndex = App.DefaultTimeRangeHours switch
-        {
-            1 => 0,
-            4 => 1,
-            12 => 2,
-            24 => 3,
-            168 => 4,
-            _ => 1
-        };
+        /* #5562: the shared picker. The zone is read lazily (display mode, this tab's own server clock), so a mode switch
+           or a refreshed clock needs only RangePicker.Refresh(). The saved default is default_time_range, else
+           default_time_range_hours through FromLegacyHours; Value does not raise RangeChanged, so this restore neither
+           persists nor refreshes. */
+        RangePicker.ZoneProvider = GetPickerZone;
+        RangePicker.Value = App.DefaultTimeRange;
+        RangePicker.DataStartUtc = LiteTimeRange.DataStartFor(null, DateTime.UtcNow);
 
         /* #3479: restore the auto-refresh toggle and interval the same way the time range is restored
            above — from the App-level setting, before _refreshTimer exists. Setting these fires their
@@ -246,9 +244,6 @@ refresh once when it becomes visible again so it isn't showing stale data on ret
         /* Show warning on Running Jobs tab if login lacks msdb access, except where the collector cannot run at all */
         RunningJobsMsdbWarning.Visibility = RunningJobsMsdbWarningVisibility(_hasMsdbAccess, _isAzureSqlDatabase, _isAwsRds);
 
-        /* Initialize time picker ComboBoxes */
-        InitializeTimeComboBoxes();
-
         /* Sync time display mode picker */
         var modeTag = ServerTimeHelper.CurrentDisplayMode.ToString();
         for (int i = 0; i < TimeDisplayModeBox.Items.Count; i++)
@@ -509,11 +504,10 @@ e.OriginalSource is not System.Windows.Controls.TextBox &&
     }
 
     /// <summary>
-    /// Returns true if the custom date range is selected and both dates are set.
+    /// Returns true when the held range carries its own instants (#5562): a sub-hour span, a calendar period, a typed or
+    /// picked range, 'since'. False for a rolling range of whole hours, which is read as "the last N hours".
     /// </summary>
-    private bool IsCustomRange => TimeRangeCombo.SelectedIndex == 5
-        && FromDatePicker?.SelectedDate != null
-        && ToDatePicker?.SelectedDate != null;
+    private bool IsCustomRange => LiteTimeRange.HasExplicitInstants(CurrentRange());
 
     /// <summary>
     /// When the user switches main tabs or sub-tabs, refresh only the visible sub-tab.
diff --git a/Lite/Helpers/LiteTimeRange.cs b/Lite/Helpers/LiteTimeRange.cs
new file mode 100644
index 0000000000..3c071022f5
--- /dev/null
+++ b/Lite/Helpers/LiteTimeRange.cs
@@ -0,0 +1,115 @@
+/*
+ * 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 PerformanceMonitor.Ui;
+using PerformanceMonitorLite.Services;
+
+namespace PerformanceMonitorLite.Helpers;
+
+/// <summary>
+/// The Lite side of the shared time range picker (#5562): how a picker value becomes the (hoursBack, fromUtc, toUtc)
+/// triple the ~60 tab consumers already take, how it is stored in settings.json, and where its notes get their data.
+/// Pure, so the tests drive it without a window.
+/// </summary>
+internal static class LiteTimeRange
+{
+    /// <summary>The range a fresh install opens on: the old default of four hours.</summary>
+    internal static TimeRangeSpec Default => TimeRangeSpec.Relative(TimeSpan.FromHours(4));
+
+    /// <summary>
+    /// The window a refresh reads. A rolling range of a whole number of hours stays (hours, null, null) exactly as the
+    /// old presets were: charts fall back to now - hoursBack. Everything else (a sub-hour span, 'Today', a typed range,
+    /// 'since') carries its two instants, and <c>hoursBack</c> is the whole hours from the start to now rounded UP (at
+    /// least 1), so a reader that only takes hours back (a history window opened from a row) still covers the range.
+    /// </summary>
+    internal static (int hoursBack, DateTime? fromUtc, DateTime? toUtc) WindowFor(ResolvedTimeRange range)
+    {
+        if (range.Spec.WholeHours is { } hours && hours > 0)
+        {
+            return (hours, null, null);
+        }
+
+        return (HoursBackFor(range), range.StartUtc, range.EndUtc);
+    }
+
+    /// <summary>Whole hours from the range's start to the moment it was resolved, rounded up, at least 1.</summary>
+    internal static int HoursBackFor(ResolvedTimeRange range)
+    {
+        var hours = Math.Ceiling((range.NowUtc - range.StartUtc).TotalHours);
+        return hours < 1 ? 1 : hours > int.MaxValue ? int.MaxValue : (int)hours;
+    }
+
+    /// <summary>
+    /// Hours back for a reader that only takes hours (the Alert and Job History reads, the FinOps lists): the picker's
+    /// range through <see cref="WindowFor"/>. A calendar period or typed range is covered from its start to now, so a
+    /// read can return rows newer than a range that ended earlier. <paramref name="fallbackHours"/> when the held range
+    /// cannot be used at this moment ('Today' in the first minutes after midnight).
+    /// </summary>
+    internal static int HoursBackOf(TimeRangePicker picker, int fallbackHours) =>
+        picker.Resolve() is { } range ? WindowFor(range).hoursBack : fallbackHours;
+
+    /// <summary>True when <paramref name="range"/> carries its own instants rather than 'the last N hours'.</summary>
+    internal static bool HasExplicitInstants(ResolvedTimeRange range) => range.Spec.WholeHours is not > 0;
+
+    /// <summary>
+    /// The range settings.json holds: the new <c>default_time_range</c> text when it names a preset or a calendar period,
+    /// else the legacy <c>default_time_range_hours</c> mapped with <see cref="TimeRangePresets.FromLegacyHours"/>, else four
+    /// hours. A typed range (fixed or 'since') is never taken from a file: it is not persisted.
+    /// </summary>
+    internal static TimeRangeSpec FromSettings(string? rangeId, int legacyHours)
+    {
+        if (TimeRangeSpec.TryFromId(rangeId, out var spec) && spec is { } s && IsPersistable(s))
+        {
+            return s;
+        }
+
+        return TimeRangePresets.FromLegacyHours(legacyHours) is { } legacy ? legacy : Default;
+    }
+
+    /// <summary>A drill window under the model's 5-minute floor, centred and widened to it; anything longer is returned as it was.</summary>
+    internal static (DateTime fromUtc, DateTime toUtc) AtLeastMinimumSpan(DateTime fromUtc, DateTime toUtc)
+    {
+        if (toUtc - fromUtc >= TimeRangeSpec.MinimumSpan)
+        {
+            return (fromUtc, toUtc);
+        }
+
+        var mid = fromUtc + (toUtc - fromUtc) / 2;
+        return (mid - TimeRangeSpec.MinimumSpan / 2, mid + TimeRangeSpec.MinimumSpan / 2);
+    }
+
+    /// <summary>A preset or calendar period persists; a typed fixed or 'since' range does not (a window that ended two days ago is worse than none).</summary>
+    internal static bool IsPersistable(TimeRangeSpec spec) =>
+        spec.Kind is TimeRangeKind.Relative or TimeRangeKind.Calendar && (spec.Kind != TimeRangeKind.Relative || spec.Span >= TimeRangeSpec.MinimumSpan);
+
+    /// <summary>
+    /// What to write for <paramref name="spec"/>: a whole-hour rolling range goes to the legacy hours key (older builds read
+    /// it) and clears the new key; any other persistable range goes to the new key. <c>(null, null)</c> for a range that is not persisted.
+    /// </summary>
+    internal static (string? rangeId, int? hours) SettingsFor(TimeRangeSpec spec)
+    {
+        if (!IsPersistable(spec))
+        {
+            return (null, null);
+        }
+
+        return spec.WholeHours is { } h && h > 0 ? (null, h) : (spec.Id, null);
+    }
+
+    /// <summary>
+    /// Where the picker's 'Data starts' note takes its start from: the coverage probe's floor the tab already awaited, else
+    /// the oldest instant the archive keeps (<see cref="RetentionService.OldestRetainedInstant"/>). No new query.
+    /// </summary>
+    internal static DateTime DataStartFor(DateTime? probedFloorUtc, DateTime utcNow) =>
+        probedFloorUtc ?? RetentionService.OldestRetainedInstant(utcNow);
+
+    /// <summary>A collector's actual cadence as the picker's sample interval; null for a collector that does not run on a schedule (0 = on load).</summary>
+    internal static TimeSpan? SampleIntervalFor(int? frequencyMinutes) =>
+        frequencyMinutes is > 0 ? TimeSpan.FromMinutes(frequencyMinutes.Value) : null;
+}
diff --git a/Lite/MainWindow.xaml.cs b/Lite/MainWindow.xaml.cs
index 2a7afa75b2..0666115e48 100644
--- a/Lite/MainWindow.xaml.cs
+++ b/Lite/MainWindow.xaml.cs
@@ -59,7 +59,7 @@ public partial class MainWindow : Window
     /// </summary>
     internal static string ConnectedStatusText(string displayName, string? suffix) =>
         string.IsNullOrEmpty(suffix) ? $"Connected to {displayName}" : $"Connected to {displayName} - {suffix}";
-    private readonly Dictionary<string, (Action<int, int, DateTime?> AlertCounts, Action<int> ApplyTimeRange, Func<Task> ManualRefresh)> _tabEventHandlers = new();
+    private readonly Dictionary<string, (Action<int, int, DateTime?> AlertCounts, Action<PerformanceMonitor.Ui.TimeRangeSpec> ApplyTimeRange, Func<Task> ManualRefresh)> _tabEventHandlers = new();
     /* Server tab badge state for the non-blocking/deadlock conditions (#754/#749), keyed by the
        ServerConnection GUID (the same key as _openServerTabs). The alert sweep sets these; both the
        blocking/deadlock tab refresh and the sweep funnel through UpdateTabBadge, so the badge
@@ -1177,7 +1177,7 @@ know about it. */
         {
             Dispatcher.Invoke(() => UpdateTabBadge(tabHeader, serverId, blockingCount, deadlockCount, latestEventTime));
         };
-        Action<int> timeRangeHandler = (selectedIndex) =>
+        Action<PerformanceMonitor.Ui.TimeRangeSpec> timeRangeHandler = (range) =>
         {
             Dispatcher.Invoke(() =>
             {
@@ -1185,7 +1185,7 @@ know about it. */
                 {
                     if (tab.Content is ServerTab st && st != serverTab)
                     {
-                        st.SetTimeRangeIndex(selectedIndex);
+                        st.SetTimeRange(range);
                     }
                 }
             });
@@ -1220,6 +1220,12 @@ registration there would wait out the reset's drain timeout. */
 
         serverTab.AlertCountsChanged += alertHandler;
         serverTab.ApplyTimeRangeRequested += timeRangeHandler;
+        /* #5562: the picker's 'collected every N minutes' note names this server's ACTUAL cadence for the tab's main
+           collector, read from the schedule each time (it can be edited while the tab is open). */
+        serverTab.SetSampleIntervalSource(() => PerformanceMonitorLite.Helpers.LiteTimeRange.SampleIntervalFor(
+            _scheduleManager.GetScheduleForServer(server.Id, ServerTab.MainCollectorName) is { Enabled: true } schedule
+                ? schedule.FrequencyMinutes
+                : null));
         serverTab.ManualRefreshRequested += refreshHandler;
         /* #1319: persist the per-server view database filter (no credential side effects). The handler
            captures only the long-lived _serverManager, so it needs no explicit unsubscribe. */
diff --git a/Lite/Windows/SettingsWindow.xaml b/Lite/Windows/SettingsWindow.xaml
index 44eb109953..8ba8eedf86 100644
--- a/Lite/Windows/SettingsWindow.xaml
+++ b/Lite/Windows/SettingsWindow.xaml
@@ -113,13 +113,8 @@
                 <StackPanel Orientation="Horizontal" Margin="0,8,0,0">
                     <TextBlock Text="Default time range:" VerticalAlignment="Center"
                                Foreground="{DynamicResource ForegroundBrush}" Margin="0,0,8,0"/>
-                    <ComboBox x:Name="DefaultTimeRangeCombo" Width="140" VerticalAlignment="Center">
-                        <ComboBoxItem Content="Last 1 hour"/>
-                        <ComboBoxItem Content="Last 4 hours"/>
-                        <ComboBoxItem Content="Last 12 hours"/>
-                        <ComboBoxItem Content="Last 24 hours"/>
-                        <ComboBoxItem Content="Last 7 days"/>
-                    </ComboBox>
+                    <!-- #5562: the shared picker. A typed or picked fixed range is not a default; it is not saved. -->
+                    <ui:TimeRangePicker x:Name="DefaultTimeRangePicker" VerticalAlignment="Center"/>
                 </StackPanel>
                 <StackPanel Orientation="Horizontal" Margin="0,8,0,0">
                     <TextBlock Text="Connection timeout:" VerticalAlignment="Center"
diff --git a/Lite/Windows/SettingsWindow.xaml.cs b/Lite/Windows/SettingsWindow.xaml.cs
index 8d81f702a3..d85cd11efd 100644
--- a/Lite/Windows/SettingsWindow.xaml.cs
+++ b/Lite/Windows/SettingsWindow.xaml.cs
@@ -21,6 +21,7 @@
 using PerformanceMonitor.Alerting;
 using PerformanceMonitor.Notifications;
 using PerformanceMonitorLite.Mcp;
+using PerformanceMonitorLite.Helpers;
 using PerformanceMonitorLite.Services;
 using PerformanceMonitor.Ui;
 using PerformanceMonitor.Common;
@@ -489,15 +490,9 @@ it could be wrong about. */
 
     private void LoadDefaultTimeRange()
     {
-        DefaultTimeRangeCombo.SelectedIndex = App.DefaultTimeRangeHours switch
-        {
-            1 => 0,
-            4 => 1,
-            12 => 2,
-            24 => 3,
-            168 => 4,
-            _ => 1
-        };
+        /* The default is a preset or a calendar period: default_time_range, else the legacy hours key through
+           FromLegacyHours (#5562). The picker's zone is this machine's, since no server is in play here. */
+        DefaultTimeRangePicker.Value = App.DefaultTimeRange;
     }
 
     /* The local WriteSetting alias is gone with #2433: every Save* below now mutates the one document
@@ -507,19 +502,16 @@ private void LoadDefaultTimeRange()
 
     private void SaveDefaultTimeRange(JsonNode root)
     {
-        var hours = DefaultTimeRangeCombo.SelectedIndex switch
+        /* A typed or picked fixed range is not a default (it would reopen on a window that has moved on): the saved
+           default is left as it was. Everything else follows the one split the toolbar uses, so the two keys never disagree. */
+        var (rangeId, hours) = LiteTimeRange.SettingsFor(DefaultTimeRangePicker.Value);
+        if (rangeId == null && hours == null)
         {
-            0 => 1,
-            1 => 4,
-            2 => 12,
-            3 => 24,
-            4 => 168,
-            _ => 4
-        };
-
-        App.DefaultTimeRangeHours = hours;
+            return;
+        }
 
-        root["default_time_range_hours"] = hours;
+        App.ApplyDefaultTimeRange(rangeId, hours);
+        App.WriteDefaultTimeRange(root, rangeId, hours);
     }
 
     private void CopyMcpCommandButton_Click(object sender, RoutedEventArgs e)
diff --git a/Lite/config/settings.sample.json b/Lite/config/settings.sample.json
index 6cd1246736..9b49d37754 100644
--- a/Lite/config/settings.sample.json
+++ b/Lite/config/settings.sample.json
@@ -148,7 +148,8 @@
   "minimize_to_tray": true,
   "time_display_mode": "ServerTime",   // "ServerTime" | "LocalTime" | "UTC"
   "color_theme": "Dark",               // "Dark" | "Light" | "CoolBreeze"
-  "default_time_range_hours": 4,       // initial range on every chart
+  "default_time_range_hours": 4,       // initial range on every chart, in whole hours (older builds read only this)
+  "default_time_range": "",            // optional (#5562), wins over the hours key: "30m" | "2d" | "1mo" | "today" | "previous-week" ... ("" = use the hours key)
 
   // ---- Auto-refresh (#3479) ------------------------------------------------------------------------
   // The server-tab toolbar's Auto-refresh checkbox and interval picker, written by the app when

From abccc7a15587d647c1bdeccfe1e60a60d43eb4ba Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 10:53:14 -0400
Subject: [PATCH 09/33] Lite: HoursBackOf spelled without an empty-brace
 pattern, cref follows LiteTimeRange (#5562)

---
 Lite.Tests/QueriesTabWindowRoundTripTests.cs | 2 +-
 Lite/Helpers/LiteTimeRange.cs                | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/Lite.Tests/QueriesTabWindowRoundTripTests.cs b/Lite.Tests/QueriesTabWindowRoundTripTests.cs
index d7f16fd385..da95cf00aa 100644
--- a/Lite.Tests/QueriesTabWindowRoundTripTests.cs
+++ b/Lite.Tests/QueriesTabWindowRoundTripTests.cs
@@ -17,7 +17,7 @@ namespace PerformanceMonitorLite.Tests;
 
 /// <summary>
 /// #4766: a custom range on the Queries tab comes back as the instants that were picked. The tab holds the range
-/// as UTC instants (<see cref="PerformanceMonitorLite.Controls.ServerTab.CurrentWindowUtc"/>) and the toolbar pickers only show them in the display
+/// as UTC instants (<see cref="PerformanceMonitorLite.Helpers.LiteTimeRange.WindowFor"/>, #5562) and the toolbar picker only shows them in the display
 /// zone; <see cref="LocalDataService.GetQueriesTabWindowUtc"/> hands the same two instants to the read that compares
 /// them against <c>collection_time</c>. No conversion sits between the pickers and the read, so the window is the
 /// instant the user picked in every display mode, on either side of a clock change (the second 01:30 of the
diff --git a/Lite/Helpers/LiteTimeRange.cs b/Lite/Helpers/LiteTimeRange.cs
index 3c071022f5..8deed821f8 100644
--- a/Lite/Helpers/LiteTimeRange.cs
+++ b/Lite/Helpers/LiteTimeRange.cs
@@ -51,8 +51,11 @@ internal static int HoursBackFor(ResolvedTimeRange range)
     /// read can return rows newer than a range that ended earlier. <paramref name="fallbackHours"/> when the held range
     /// cannot be used at this moment ('Today' in the first minutes after midnight).
     /// </summary>
-    internal static int HoursBackOf(TimeRangePicker picker, int fallbackHours) =>
-        picker.Resolve() is { } range ? WindowFor(range).hoursBack : fallbackHours;
+    internal static int HoursBackOf(TimeRangePicker picker, int fallbackHours)
+    {
+        var range = picker.Resolve();
+        return range != null ? WindowFor(range).hoursBack : fallbackHours;
+    }
 
     /// <summary>True when <paramref name="range"/> carries its own instants rather than 'the last N hours'.</summary>
     internal static bool HasExplicitInstants(ResolvedTimeRange range) => range.Spec.WholeHours is not > 0;

From cf5a64a457a55f842f277705d0fdd5021e7b2450 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:06:02 -0400
Subject: [PATCH 10/33] Web pages move onto the shared time range picker; the
 server page notes how often a tab's data is collected (#5562)

---
 .../wwwroot/js/editor.js                      |  23 ++--
 .../wwwroot/js/page-range.js                  | 127 ++++++++++++++++++
 .../wwwroot/js/pages/alerts.js                |  40 +++---
 .../js/pages/finops/database-resources.js     |  27 +---
 .../wwwroot/js/pages/finops/high-impact.js    |  24 +---
 .../wwwroot/js/pages/finops/optimization.js   |  26 +---
 .../wwwroot/js/pages/finops/storage-growth.js |  33 +++--
 .../wwwroot/js/pages/finops/window.js         |  50 +++++++
 .../wwwroot/js/pages/job-history.js           |  51 ++++---
 .../wwwroot/js/pages/server-tabs.js           |   9 ++
 .../wwwroot/js/pages/server.js                |  27 ++++
 .../wwwroot/js/pages/sweeps.js                |  53 +++++---
 .../wwwroot/js/pages/views.js                 | 103 +++-----------
 .../wwwroot/js/time-range-picker.js           |  47 +++++--
 .../wwwroot/js/time-range.js                  |  24 ++++
 15 files changed, 418 insertions(+), 246 deletions(-)
 create mode 100644 Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
 create mode 100644 Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js

diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/editor.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/editor.js
index 197c98f31c..94cd04d455 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/editor.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/editor.js
@@ -37,6 +37,7 @@ import * as api from "./views-api.js";
 import { refreshChoiceOf } from "./refresh-policy.js";
 import { buildRefreshControl } from "./refresh-control.js";
 import * as derive from "./derive.js";
+import { rollingHoursPicker } from "./page-range.js";
 
 /** The FORMATTERS keys the format pickers offer (mirrors util.js FORMATTERS). */
 const FORMAT_OPTIONS = ["text", "int", "num1", "num2", "rate", "pct", "ms", "mb", "time", "reltime", "bool"];
@@ -52,6 +53,8 @@ const RANGE_OPTIONS = [
   { hours: 24 * 90, label: "Last 90 days" },
 ];
 const DEFAULT_RANGE_HOURS = 24;
+/** The longest default range a view takes: the compose runner's window ceiling (ComposeLimits.MaxWindowHours, 90 days). */
+const MAX_VIEW_RANGE_HOURS = 24 * 90;
 
 /** The default chart per composed-panel shape (a working chart the instant a measure is picked). */
 const DEFAULT_VIZ_FOR_SHAPE = { timeseries: "line", topseries: "line", ranked: "bar", scalar: "stat" };
@@ -1817,14 +1820,18 @@ export function buildViewScopeSection(model, catalog, onStructuralChange) {
   const compose = catalog.compose || {};
   const dimNames = variableDimensionNames(compose);
 
-  const rangeSel = el("select", { class: "editor-select", "aria-label": "Default time range" });
-  rangeSel.appendChild(el("option", { value: "", text: "Default (last 24 hours)" }));
-  for (const r of RANGE_OPTIONS) rangeSel.appendChild(el("option", { value: String(r.hours), text: r.label }));
-  rangeSel.value = model.rangeHours != null ? String(model.rangeHours) : "";
-  rangeSel.addEventListener("change", () => {
-    model.rangeHours = rangeSel.value ? parseInt(rangeSel.value, 10) : null;
-    onStructuralChange();
-  });
+  /* The view's default range is "this many hours back from now" (def.range.hours), so it is the shared picker's rolling-only form
+     (#5562): up to the compose runner's 90 days, a longer length greyed out with the reason, never clamped. It starts on the saved
+     hours, or the 24 hour default for a view with none, and saves what the reader picks. */
+  const rangeSel = rollingHoursPicker({
+    hours: model.rangeHours != null ? model.rangeHours : DEFAULT_RANGE_HOURS,
+    reachHours: MAX_VIEW_RANGE_HOURS,
+    label: "Default time range",
+    onChange: (hours) => {
+      model.rangeHours = hours;
+      onStructuralChange();
+    },
+  }).node;
 
   const varsBox = el("div", { class: "item-list vars" });
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
new file mode 100644
index 0000000000..6ccd8b2802
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/*
+ * The shared time range picker on a page that shows ONE read (#5562, lane L2b): the alerts, sweeps, job history, FinOps, views and
+ * view-editor pages. It mounts timeRangePicker with the page's range and fills in what only the catalog knows once /api/catalog
+ * answers: the read's reach (`max_hours`, so a range the read refuses is greyed out with the reason, never clamped) and the main
+ * collector's actual interval (`collector_interval_minutes`, so a span holding fewer than 3 samples says how often the data is
+ * collected, and never widens the range). Until the catalog answers the picker holds the common 168 hour reach and no note.
+ *
+ *   const { picker, ready } = pageRangePicker({ read: "get_job_history", spec, onChange: (spec, range) => reload() });
+ *   host.appendChild(picker.node);
+ *   const w = picker.window();   // { hours, asOf, live, startMs, endMs }: send `hours`, and `as_of` when it is not null
+ *
+ * `rollingOnly` is the FinOps shape (R5): "this many hours back from now", no calendar periods, no custom end, at least an hour.
+ */
+
+import { timeRangePicker } from "./time-range-picker.js";
+import { reachHours, collectorIntervalMs, resolveSpec, readWindow, browserZone, relativeSpec } from "./time-range.js";
+import { getCatalog } from "./views-api.js";
+import { apiGet } from "./util.js";
+
+const serverCatalogs = new Map();
+
+/** The window a read takes for a held spec as of now: `{ hours, asOf, live, startMs, endMs }`, or null when the spec cannot be resolved
+ *  (a calendar period under five minutes old). A page that keeps its choice at module scope (so a 60 s poll or a visit elsewhere keeps
+ *  it) calls this on every read, so a live range slides with the clock. */
+export function windowOfSpec(spec, nowMs = Date.now(), zone = browserZone()) {
+  const r = resolveSpec(spec, nowMs, zone);
+  return r.ok ? readWindow(r.range) : null;
+}
+
+/** One catalog entry by read name from the fleet-wide catalog, or null. */
+export async function catalogEntryFor(read) {
+  const catalog = await getCatalog();
+  return (catalog.reads || []).find((r) => r && r.name === read) || null;
+}
+
+/** The catalog with the SERVER's own collector intervals (a per-server schedule row wins), cached per server. Null when it cannot be read. */
+export function serverCatalog(server) {
+  if (!serverCatalogs.has(server)) {
+    serverCatalogs.set(
+      server,
+      apiGet("/api/catalog?server=" + encodeURIComponent(server)).then((r) => (r.kind === "data" && r.data ? r.data : null))
+    );
+  }
+  return serverCatalogs.get(server);
+}
+
+/** The interval, in milliseconds, of one collector on this server as the catalog serves it: every read of a collector carries the same
+ *  schedule, so the first windowed read that names the collector answers. Null when none does (no note). */
+export function collectorIntervalFromCatalog(catalog, collector) {
+  if (!catalog || !collector) return null;
+  for (const entry of catalog.reads || []) {
+    const param = entry && Array.isArray(entry.params) ? entry.params.find((p) => p && p.name === "hours") : null;
+    if (param && param.collector === collector) {
+      const ms = collectorIntervalMs(entry);
+      if (ms) return ms;
+    }
+  }
+  return null;
+}
+
+/**
+ * Mounts the picker for one read. `ready` resolves after the catalog entry has set the reach and the sample interval; a page that
+ * must wait for the reach (to restore a stored range) can await it.
+ *
+ * @param {object} opts
+ * @param {string} opts.read the catalog read the page calls (its `hours` param carries the reach and the collector's interval)
+ * @param {number} [opts.reachHours] a reach the page knows better than the read-level catalog (a view of get_finops that reaches further)
+ * @param {string} [opts.server] ask the catalog for this server's own collector interval
+ * @param {boolean} [opts.useCatalogInterval] default true; false for a read that no collector feeds
+ */
+export function pageRangePicker(opts) {
+  const picker = timeRangePicker(opts);
+  const ready = (async () => {
+    try {
+      const entry = await catalogEntryFor(opts.read);
+      picker.setReach(opts.reachHours > 0 ? opts.reachHours : reachHours(entry));
+      if (opts.useCatalogInterval === false) return;
+      if (opts.server) {
+        const interval = collectorIntervalFromCatalog(await serverCatalog(opts.server), entry && entry.params ? hoursParam(entry).collector : null);
+        picker.setSampleInterval(interval || collectorIntervalMs(entry));
+      } else {
+        picker.setSampleInterval(collectorIntervalMs(entry));
+      }
+    } catch {
+      /* A catalog that cannot be read leaves the common reach and no note, exactly the picker's defaults. */
+    }
+  })();
+  return { picker, ready };
+}
+
+function hoursParam(entry) {
+  return (entry.params || []).find((p) => p && p.name === "hours") || {};
+}
+
+/**
+ * A rolling-only picker for a page whose setting is "this many hours back from now" and whose reach is its own, not one read's: a
+ * Custom View's scope (the compose runner takes up to 90 days) and the view editor's default range. It offers no calendar period
+ * and no custom end, because the stored setting is a number of hours, and it greys out what is longer than `reachHours` with the
+ * reason instead of clamping it.
+ *
+ * @param {object} opts
+ * @param {number} opts.hours the length to start on, in whole hours
+ * @param {number} opts.reachHours the longest length the page takes
+ * @param {(hours: number) => void} opts.onChange raised with the whole hours picked
+ * @param {string} [opts.label] the accessible name
+ */
+export function rollingHoursPicker(opts) {
+  const picker = timeRangePicker({
+    spec: relativeSpec(opts.hours * 3600000),
+    label: opts.label || "Time range",
+    reachHours: opts.reachHours,
+    rollingOnly: true,
+    onChange: () => {
+      const w = picker.window();
+      if (w) opts.onChange(w.hours);
+    },
+  });
+  return picker;
+}
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
index 54b60054bc..7e3c2bd2eb 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
@@ -27,6 +27,8 @@ import { el, mount, readTool, apiSend, buildQuery, loadingStrip, errorStrip, emp
          ALERT_STATE_LABELS, alertDeliveryState } from "../util.js";
 import { VIZ, reapplyGridSort, gridRowOf } from "../panels.js";
 import { copyText } from "../grid-tools.js";
+import { pageRangePicker, windowOfSpec } from "../page-range.js";
+import { relativeSpec, specName } from "../time-range.js";
 import { mutePrefillParams } from "../mute-context.js";
 import { orderServers } from "../server-order.js";
 import { getSession } from "../views-api.js";
@@ -409,23 +411,22 @@ function reconcileRows(tbody, rows, rowMap) {
 }
 
 /* The four read choices, kept at module scope so the 60 s poll (which calls renderAlerts again) and a visit to
- * another page and back keep them. The windows are the desktop Alert History's, less "All": the tool refuses
- * more than 168 hours, and a choice it would refuse is not offered. The row limits stop at the dispatch
- * layer's 1000-row ceiling. The server is the registry's server_name ("" = the whole fleet). */
-const WINDOW_CHOICES = [
-  { hours: 1, label: "Last 1 Hour" },
-  { hours: 4, label: "Last 4 Hours" },
-  { hours: 24, label: "Last 24 Hours" },
-  { hours: 168, label: "Last 7 Days" },
-];
+ * another page and back keep them. The range is the shared time range picker's spec (#5562), read as of each read so a
+ * rolling range slides. The picker takes the reach from the catalog (get_alert_history reaches 168 hours), so a longer
+ * range is greyed out with the reason, never clamped, and there is no All. The alert table itself keeps 90 days
+ * (DarlingRetention.AlertHistoryRetentionDays, R8), but the web read stops at the common 7 day reach (R2). The row limits
+ * stop at the dispatch layer's 1000-row ceiling. The server is the registry's server_name ("" = the whole fleet). */
+const DEFAULT_HOURS = 24;
 const LIMIT_CHOICES = [200, 500, 1000];
-const choices = { hours: 24, limit: 200, server: "", dismissed: false };
+const choices = { spec: relativeSpec(DEFAULT_HOURS * 3600000), limit: 200, server: "", dismissed: false };
 
 /* The get_alert_history parameters the current choices ask for. server_name and include_dismissed are left out
- * (buildQuery drops empty values) when they are at their defaults. */
+ * (buildQuery drops empty values) when they are at their defaults, and as_of when the range ends now. */
 function readParams() {
+  const w = windowOfSpec(choices.spec);
   return {
-    hours_back: choices.hours,
+    hours_back: w ? w.hours : DEFAULT_HOURS,
+    as_of: w ? w.asOf : null,
     limit: choices.limit,
     server_name: choices.server || null,
     include_dismissed: choices.dismissed ? "true" : null,
@@ -433,7 +434,7 @@ function readParams() {
 }
 
 function windowLabel() {
-  return (WINDOW_CHOICES.find((w) => w.hours === choices.hours) || WINDOW_CHOICES[2]).label.toLowerCase();
+  return specName(choices.spec).toLowerCase();
 }
 
 /* The server names list_servers reported on the last successful read; the picker keeps the chosen server in the
@@ -589,8 +590,14 @@ export async function renderAlerts(main) {
     "aria-label": "Filter alerts by server",
   });
 
-  const windowSel = picker("Time range", WINDOW_CHOICES.map((w) => ({ value: w.hours, label: w.label })), choices.hours);
-  windowSel.setAttribute("title", "The web reads at most 7 days of alert history, so there is no All choice.");
+  const rangePicker = pageRangePicker({
+    read: "get_alert_history",
+    spec: choices.spec,
+    label: "Time range",
+    /* No collector feeds the alert log, so there is no "collected every N minutes" note. */
+    useCatalogInterval: false,
+    onChange: (spec) => { choices.spec = spec; changed(); },
+  }).picker;
   const limitSel = picker("Row limit", LIMIT_CHOICES.map((n) => ({ value: n, label: n + " rows" })), choices.limit);
   const serverSel = picker("Server", serverItems(), choices.server);
   const dismissedBox = el("input", { type: "checkbox", "aria-label": "Show dismissed alerts" });
@@ -603,7 +610,7 @@ export async function renderAlerts(main) {
     el("h2", { text: "Alert History" }),
     meta,
     el("div", { class: "spacer" }),
-    control("Range", windowSel),
+    el("div", { class: "range-control" }, [el("span", { text: "Range" }), rangePicker.node]),
     control("Rows", limitSel),
     control("Server", serverSel),
     el("label", { class: "range-control" }, [dismissedBox, el("span", { text: "Show dismissed" })]),
@@ -615,7 +622,6 @@ export async function renderAlerts(main) {
   /* A changed choice refetches and reconciles the table that is already drawn, the same path a poll tick takes.
      It also drops the checked rows: they were picked from the list the old choice showed. */
   const changed = () => { clearSelection(live); return refreshAlerts(live); };
-  windowSel.addEventListener("change", () => { choices.hours = Number(windowSel.value); changed(); });
   limitSel.addEventListener("change", () => { choices.limit = Number(limitSel.value); changed(); });
   serverSel.addEventListener("change", () => { choices.server = serverSel.value; changed(); });
   dismissedBox.addEventListener("change", () => { choices.dismissed = !!dismissedBox.checked; changed(); });
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/database-resources.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/database-resources.js
index d955e8d864..f69c24798d 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/database-resources.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/database-resources.js
@@ -7,36 +7,16 @@
  */
 
 /* FinOps "Database Resources" tab: per-database CPU, reads, writes, executions and file I/O from get_finops
-   (view database_resources) over a window picked from 1 hour to 7 days, with each database's share of the server's CPU and I/O. */
+   (view database_resources) over a window picked on the shared time range picker (#5562: a rolling length of at least an hour, within the read's reach), with each database's share of the server's CPU and I/O. */
 
 import { VIZ } from "../../panels.js";
 import { el, mount, loadingStrip, noticeStrip, readErrorStrip, errorStrip, readTool } from "../../util.js";
 import { gatedEmptyStrip } from "./gate.js";
+import { finopsWindowControl } from "./window.js";
 
 // The default window.
 const HOURS = 24;
 
-// The desktop's window picker (FinOpsTab.xaml ~:497-499), as hours.
-const WINDOWS = [
-  { value: 1, label: "Last 1 hour" },
-  { value: 4, label: "Last 4 hours" },
-  { value: 12, label: "Last 12 hours" },
-  { value: 24, label: "Last 24 hours" },
-  { value: 168, label: "Last 7 days" },
-];
-
-// A labelled <select> (the server-tabs.js pickerControl pattern); every value goes through el()'s text and attribute paths.
-function pickerControl(label, options, selected, onPick) {
-  const sel = el(
-    "select",
-    { class: "range-select-inline", "aria-label": label },
-    options.map((o) => el("option", { value: o.value, text: o.label }))
-  );
-  sel.value = String(selected);
-  sel.addEventListener("change", () => onPick(Number(sel.value)));
-  return el("label", { class: "range-control" }, [el("span", { text: label }), sel]);
-}
-
 const COLUMNS = [
   { key: "database_name", label: "Database" },
   { key: "cpu_time_ms", label: "CPU", format: "ms" },
@@ -83,7 +63,8 @@ export const tab = {
         if (mine === seq && e?.name !== "AbortError") mount(body, errorStrip("Could not render this tab: " + (e && e.message ? e.message : String(e))));
       }
     };
-    const root = el("div", {}, [pickerControl("Window", WINDOWS, HOURS, (hours) => load(hours)), body]);
+    const win = finopsWindowControl({ hours: HOURS, onChange: (hours) => load(hours) });
+    const root = el("div", {}, [win.node, body]);
     load(HOURS);
     return root;
   },
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/high-impact.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/high-impact.js
index 2a94c540f6..0d0beaf7b4 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/high-impact.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/high-impact.js
@@ -14,33 +14,14 @@ import { VIZ } from "../../panels.js";
 import { planColumn } from "../plan-viewer.js";
 import { el, mount, loadingStrip, noticeStrip, readErrorStrip, errorStrip, readTool } from "../../util.js";
 import { gatedEmptyStrip } from "./gate.js";
+import { finopsWindowControl } from "./window.js";
 
 // The default window.
 const HOURS = 24;
 
-// The desktop's window choices (FinOpsTab.xaml ~:874), as hours.
-const WINDOWS = [
-  { value: 1, label: "Last 1 hour" },
-  { value: 4, label: "Last 4 hours" },
-  { value: 12, label: "Last 12 hours" },
-  { value: 24, label: "Last 24 hours" },
-  { value: 168, label: "Last 7 days" },
-];
-
 // The chosen window per server, kept here so the 60 s rebuild of the tab does not put it back to 24 hours.
 const chosenHours = new Map();
 
-// A labelled <select> (the server-tabs.js pickerControl pattern); every value goes through el()'s text and attribute paths.
-function pickerControl(label, options, selected, onPick) {
-  const sel = el(
-    "select",
-    { class: "range-select-inline", "aria-label": label },
-    options.map((o) => el("option", { value: o.value, text: o.label }))
-  );
-  sel.value = String(selected);
-  sel.addEventListener("change", () => onPick(Number(sel.value)));
-  return el("label", { class: "range-control" }, [el("span", { text: label }), sel]);
-}
 const LIMIT = 10;
 
 const COLUMNS = [
@@ -97,7 +78,8 @@ export const tab = {
       }
     };
     const start = chosenHours.get(server) ?? HOURS;
-    const root = el("div", {}, [pickerControl("Window", WINDOWS, start, (hours) => load(hours)), body]);
+    const win = finopsWindowControl({ hours: start, onChange: (hours) => load(hours) });
+    const root = el("div", {}, [win.node, body]);
     load(start);
     return root;
   },
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/optimization.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/optimization.js
index c3ff4d17bf..10b9247db6 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/optimization.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/optimization.js
@@ -15,35 +15,16 @@ import { VIZ } from "../../panels.js";
 import { planColumn } from "../plan-viewer.js";
 import { el, mount, loadingStrip, emptyStrip, noticeStrip, readErrorStrip, errorStrip, readTool, applyFormat } from "../../util.js";
 import { gatedEmptyStrip, gatedSections } from "./gate.js";
+import { finopsWindowControl } from "./window.js";
 
 // The default window.
 const HOURS = 24;
 
-// The desktop's window choices (FinOpsTab.xaml ~:791 Wait Stats and ~:818 Expensive Queries), as hours. The desktop has a
-// picker for each of those two sections; the web keeps ONE picker that moves both. The other sections stay fixed, as on
-// the desktop.
-const WINDOWS = [
-  { value: 1, label: "Last 1 hour" },
-  { value: 4, label: "Last 4 hours" },
-  { value: 12, label: "Last 12 hours" },
-  { value: 24, label: "Last 24 hours" },
-  { value: 168, label: "Last 7 days" },
-];
+// ONE picker moves both the Wait Stats and Expensive Queries windows (the desktop has one for each); the other sections stay fixed.
 
 // The chosen window per server, kept here so the 60 s rebuild of the tab does not put it back to 24 hours.
 const chosenHours = new Map();
 
-// A labelled <select> (the server-tabs.js pickerControl pattern); every value goes through el()'s text and attribute paths.
-function pickerControl(label, options, selected, onPick) {
-  const sel = el(
-    "select",
-    { class: "range-select-inline", "aria-label": label },
-    options.map((o) => el("option", { value: o.value, text: o.label }))
-  );
-  sel.value = String(selected);
-  sel.addEventListener("change", () => onPick(Number(sel.value)));
-  return el("label", { class: "range-control" }, [el("span", { text: label }), sel]);
-}
 const LIMIT = 20;
 
 const IDLE_COLUMNS = [
@@ -171,7 +152,8 @@ export const tab = {
       }
     };
     const start = chosenHours.get(server) ?? HOURS;
-    const root = el("div", {}, [pickerControl("Window", WINDOWS, start, (hours) => load(hours)), body]);
+    const win = finopsWindowControl({ hours: start, onChange: (hours) => load(hours) });
+    const root = el("div", {}, [win.node, body]);
     load(start);
     return root;
   },
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
index 99afea3b5e..37b1eb5ba6 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
@@ -15,6 +15,7 @@
 import { VIZ } from "../../panels.js";
 import { el, mount, loadingStrip, emptyStrip, noticeStrip, readErrorStrip, errorStrip, readTool, applyFormat, relTime, localTime } from "../../util.js";
 import { gatedEmptyStrip, gatedSections } from "./gate.js";
+import { finopsWindowControl } from "./window.js";
 
 const HOURS = 24;
 const OBJECT_LIMIT = 20;
@@ -22,12 +23,11 @@ const OBJECT_LIMIT = 20;
 // Database Sizes tab asks for its 500 files; the service's own default is the top 50 by 30-day growth.
 const DATABASE_LIMIT = 500;
 
-// The objects window, in days: the desktop's 7 / 30 / 90 picker. The service reads it as hours_back (days * 24); 30 days is its default.
-const WINDOWS = [
-  { value: 7, label: "Last 7 days" },
-  { value: 30, label: "Last 30 days" },
-  { value: 90, label: "Last 90 days" },
-];
+// The objects window, in whole days (the heatmap has one column per day). The service reads it as hours_back (days * 24) and takes up to
+// 2160 hours for this view (DarlingMcpFinOpsTools.cs: "storage_growth: max 2160"), though the get_finops catalog entry says 168 for its
+// other views, so the picker is given this view's own reach. 30 days is the default.
+const DAY_MS = 86400000;
+const STORAGE_GROWTH_REACH_HOURS = 2160;
 const DEFAULT_DAYS = 30;
 
 // The drill per server: { level, database, object, days }. It lives at module scope because the page's 60 s poll calls build()
@@ -192,17 +192,16 @@ export const tab = {
 
     // The window picker (objects level only); the choice is kept in the drill, so the 60 s rebuild does not put it back to 30 days.
     function windowPicker() {
-      const sel = el(
-        "select",
-        { class: "range-select-inline", "aria-label": "Window" },
-        WINDOWS.map((w) => el("option", { value: w.value, text: w.label }))
-      );
-      sel.value = String(state.days);
-      sel.addEventListener("change", () => {
-        state.days = Number(sel.value);
-        load();
-      });
-      return el("label", { class: "range-control" }, [el("span", { text: "Window" }), sel]);
+      return finopsWindowControl({
+        hours: state.days * 24,
+        reachHours: STORAGE_GROWTH_REACH_HOURS,
+        minSpanMs: DAY_MS,
+        stepMs: DAY_MS,
+        onChange: (hours) => {
+          state.days = hours / 24;
+          load();
+        },
+      }).node;
     }
 
     function chrome(content) {
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
new file mode 100644
index 0000000000..7ddac64bc3
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/* The FinOps pages' window control (#5562 R5): the shared time range picker, in its Compact, rolling-only form. Every FinOps read is
+   "this many hours back from now" (`hours`, no `as_of`), so the control offers no calendar period, no custom end and nothing under
+   an hour, and a range the read cannot honor is greyed out with the reason rather than read differently. The reach is the read's
+   own, from the catalog (`max_hours`); a view that reaches further than its read's catalog entry says passes its own. */
+
+import { el } from "../../util.js";
+import { pageRangePicker } from "../../page-range.js";
+import { relativeSpec, ROLLING_ONLY_MIN_SPAN_MS } from "../../time-range.js";
+
+const HOUR_MS = 3600000;
+
+/**
+ * @param {object} opts
+ * @param {number} opts.hours the window to start on, in whole hours
+ * @param {(hours: number) => void} opts.onChange raised with the whole hours the reader picked
+ * @param {number} [opts.reachHours] the view's own reach, when it is longer than the read's catalog reach
+ * @param {number} [opts.minSpanMs] a floor above one hour (a daily read)
+ * @param {number} [opts.stepMs] the unit a length must be a whole number of (default one hour)
+ * @param {string} [opts.label] the control's label (default "Window")
+ * @returns {{ node: HTMLElement, picker: object, hours: () => number }}
+ */
+export function finopsWindowControl(opts) {
+  const label = opts.label || "Window";
+  const { picker } = pageRangePicker({
+    read: "get_finops",
+    spec: relativeSpec(opts.hours * HOUR_MS),
+    label,
+    compact: true,
+    rollingOnly: true,
+    minSpanMs: opts.minSpanMs || ROLLING_ONLY_MIN_SPAN_MS,
+    stepMs: opts.stepMs,
+    reachHours: opts.reachHours,
+    /* No collector feeds the FinOps views as one read, so there is no "collected every N minutes" note here. */
+    useCatalogInterval: false,
+    onChange: () => opts.onChange(currentHours()),
+  });
+  const currentHours = () => {
+    const w = picker.window();
+    return w ? w.hours : opts.hours;
+  };
+  return { node: el("div", { class: "range-control" }, [el("span", { text: label }), picker.node]), picker, hours: currentHours };
+}
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js
index 5e18539c04..237b07a7cc 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js
@@ -22,17 +22,13 @@
  */
 
 import { VIZ } from "../panels.js";
+import { pageRangePicker, windowOfSpec } from "../page-range.js";
+import { relativeSpec } from "../time-range.js";
 import { orderServers } from "../server-order.js";
 import { el, mount, clear, loadingStrip, emptyStrip, noticeStrip, errorStrip, readErrorStrip, readTool, readToolWithinKeptHistory, keptWindowStrip, localTime } from "../util.js";
 
-/** The window choices: the house presets, in hours. */
-export const WINDOWS = [
-  { value: 1, label: "Last 1 hour" },
-  { value: 4, label: "Last 4 hours" },
-  { value: 12, label: "Last 12 hours" },
-  { value: 24, label: "Last 24 hours" },
-  { value: 168, label: "Last 7 days" },
-];
+/** The default range, in hours. The range itself is the shared time range picker's (#5562). */
+export const DEFAULT_HOURS = 24;
 
 /** The run statuses the read accepts; an empty value is every status. */
 export const STATUSES = [
@@ -62,7 +58,7 @@ export const JOB_HISTORY_COLUMNS = [
 
 /* The filter state, kept across the 60 s rebuild. `jobDraft` is the job text as typed, applied on Enter or when
    the box loses focus; `job` is the text the last read used. */
-const state = { server: "", hours: 24, status: "", category: "", limit: 100, job: "", jobDraft: "", jobFocused: false, jobCaret: null };
+const state = { server: "", spec: relativeSpec(DEFAULT_HOURS * 3600000), status: "", category: "", limit: 100, job: "", jobDraft: "", jobFocused: false, jobCaret: null };
 /* The categories seen in any answer, so the Category choices survive a filter that narrows the next answer. */
 const seenCategories = new Set();
 /* The server choices from the last list_servers read, so the rebuild paints its select at once. */
@@ -122,9 +118,27 @@ function fill(sel, options, value) {
   sel.value = String(value);
 }
 
+/** The read takes whole hours back from the end, so a range of 30 minutes comes back as the whole hour. The runs are newest first, so
+ *  the row limit drops only the OLDEST ones and cutting at the range's start cannot hide a run inside it; the end is bounded in
+ *  the reader (R6), never here. */
+export function trimRunsToStart(data, w) {
+  if (!w || !Array.isArray(data.runs)) return data;
+  return {
+    ...data,
+    runs: data.runs.filter((r) => {
+      const t = Date.parse(r && r.run_time);
+      return !Number.isFinite(t) || t >= w.startMs;
+    }),
+  };
+}
+
 /** The read's parameters for the current filters; an empty filter is left off so the read applies none. */
 export function readParams() {
-  const p = { hours: state.hours, limit: state.limit };
+  /* A finished range sends its end as `as_of` (#5562 R6). The reader bounds the runs by that end in SQL, before the row limit
+     (JobHistoryFilter.UntilUtc, DarlingJobHistoryReader.cs), so the newest runs the limit keeps are the range's own. */
+  const w = windowOfSpec(state.spec) || windowOfSpec(relativeSpec(DEFAULT_HOURS * 3600000));
+  const p = { hours: w.hours, limit: state.limit };
+  if (w.asOf) p.as_of = w.asOf;
   if (state.server) p.server = state.server;
   /* The text in the box is what the next read uses, so a rebuild or another filter's change never leaves typed text unapplied. */
   state.job = state.jobDraft.trim();
@@ -199,10 +213,17 @@ export function renderJobHistory(main) {
   const body = el("div", {}, [loadingStrip("Loading job history…")]);
 
   const reload = () => load();
-  const win = select("Window", WINDOWS, state.hours, (v) => {
-    state.hours = Number(v);
-    reload();
-  });
+  /* The picker's reach comes from the catalog (get_job_history reaches 168 hours): a longer range is greyed out with the reason. */
+  const rangePicker = pageRangePicker({
+    read: "get_job_history",
+    spec: state.spec,
+    label: "Window",
+    onChange: (spec) => {
+      state.spec = spec;
+      reload();
+    },
+  }).picker;
+  const win = { label: el("div", { class: "range-control" }, [el("span", { text: "Window" }), rangePicker.node]) };
   const server = select("Server", serverOptions(), state.server, (v) => {
     state.server = v;
     reload();
@@ -284,7 +305,7 @@ export function renderJobHistory(main) {
         showAgent(null);
         return mount(body, readErrorStrip(res.message));
       }
-      const data = res.data || {};
+      const data = trimRunsToStart(res.data || {}, windowOfSpec(state.spec));
       const kept = keptWindowStrip(res);
       showAgent(res.kind === "empty" ? res.hints : data);
       if (res.kind === "empty") {
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
index 5d321078d1..8837ce625c 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
@@ -1073,6 +1073,7 @@ export const SERVER_TABS = [
   {
     id: "overview",
     label: "Overview",
+    collector: "cpu_utilization",
     build: (server, ctx) => [
       stat("Overview", "get_server_summary", { server }, OVERVIEW_STATS, SNAPSHOT, 2),
       stat("Server Properties", "get_server_properties", { server }, PROPERTY_STATS, SNAPSHOT, 2),
@@ -1121,6 +1122,7 @@ export const SERVER_TABS = [
   {
     id: "waits",
     label: "Wait Stats",
+    collector: "wait_stats",
     build: (server, ctx) => [
       waitsPanel(server, ctx),
       table(
@@ -1158,6 +1160,7 @@ export const SERVER_TABS = [
   {
     id: "cpu",
     label: "CPU",
+    collector: "cpu_utilization",
     build: (server, ctx) => [
       line("CPU Utilization", "get_cpu_utilization", { server, hours: ctx.hours }, "samples", "sample_time", CPU_SERIES, {
         subtitle: ctx.label,
@@ -1209,6 +1212,7 @@ export const SERVER_TABS = [
   {
     id: "memory",
     label: "Memory",
+    collector: "memory_stats",
     build: (server, ctx) => [
       stat("Memory", "get_memory_stats", { server }, MEMORY_STATS, SNAPSHOT, 2),
       line("Memory Trend", "get_memory_trend", { server, hours: ctx.hours }, "trend", "time", MEMORY_SERIES, {
@@ -1299,6 +1303,7 @@ export const SERVER_TABS = [
   {
     id: "blocking",
     label: "Blocking",
+    collector: "blocked_process_report",
     /* get_blocking_stats, which draws Blocking Severity and Deadlock Severity, takes any window, and its tables keep
        more than this page's widest Range. The note names that Range from the presets (tabNote), so narrowing them
        cannot leave it wrong. */
@@ -1442,6 +1447,7 @@ export const SERVER_TABS = [
   {
     id: "io",
     label: "File I/O",
+    collector: "file_io_stats",
     build: (server, ctx) => [
       fileIoPanel(server, ctx),
       table(
@@ -1496,6 +1502,7 @@ export const SERVER_TABS = [
   {
     id: "queries",
     label: "Queries",
+    collector: "query_stats",
     note:
       "Execution-plan analysis, the query heatmap, cached-plan retrieval and actual-plan re-execution are " +
       "desktop-viewer features — they need a plan renderer and a command back to the monitored server, neither " +
@@ -2575,6 +2582,7 @@ export const POSTGRES_TABS = [
   {
     id: "waits",
     label: "Waits",
+    collector: "pg_wait_sampling",
     /* THE DECISION, argued in the PR: this tab is SHOWN at every PostgreSQL target, including the stock ones
        where its read can never have content. get_pg_wait_stats reads aurora_stat_system_waits(), which core
        PostgreSQL has in no version, so on `postgres` the panel is permanently empty — and it is permanently
@@ -2640,6 +2648,7 @@ export const POSTGRES_TABS = [
   {
     id: "io",
     label: "I/O",
+    collector: "pg_io_stats",
     note:
       "PostgreSQL reports I/O by BACKEND TYPE, object and context rather than by file, so there is no " +
       "per-file grid here and the shape is deliberately not the SQL Server one. On Aurora the whole write side " +
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
index ee56325869..584dd30986 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
@@ -52,6 +52,7 @@ import { setPanelSignal } from "../panels.js";
 import { serverTabsFor, isPostgresTarget, findServerTab, tabNote } from "./server-tabs.js";
 import { metricBands } from "./fleet.js";
 import { timeRangePicker } from "../time-range-picker.js";
+import { serverCatalog, collectorIntervalFromCatalog } from "../page-range.js";
 import { browserZone, resolveSpec, relativeSpec, fixedSpec, specName, wholeHours, readWindow, reachRefusal, ROLLING_PRESETS, MINIMUM_SPAN_MS } from "../time-range.js";
 
 /** How far back this page's reads reach, in hours. All but three ranged reads on these tabs (the collection log, current waits and
@@ -296,6 +297,9 @@ function paintTabs(tabsSlot, server, tabId, card) {
 function redrawPanels() {
   if (!gridNode || !current.tab || !current.server) return;
 
+  /* Before the keepGrid return: a poll that keeps the panels still built a new picker, which needs its note. */
+  applySampleNote();
+
   if (keepGrid) {
     keepGrid = false;
     return;
@@ -370,9 +374,32 @@ function rangeControl() {
       if (holdSpec(server, spec, Date.now()) == null) redrawPanels();
     },
   });
+  rangePicker = picker;
   return el("div", { class: "range-control" }, [el("span", { text: "Range" }), picker.node]);
 }
 
+/* The picker on screen, so the tab on screen can tell it how often its data is collected (#5562 R3). */
+let rangePicker = null;
+
+/** The "collected every N minutes" note for the tab on screen (#5562 R3). Each tab declares its main collector (`collector` in
+ *  server-tabs.js); the server's catalog gives that collector's ACTUAL interval (a per-server schedule row over the fleet's over the
+ *  shipped default) as `collector_interval_minutes`. The picker shows the note when the chosen span holds fewer than 3 samples at that
+ *  interval, and never widens the range. A tab with no single main collector, or a catalog that cannot be read, shows no note. */
+function applySampleNote() {
+  const picker = rangePicker;
+  const tab = current.tab;
+  const server = current.server;
+  if (!picker) return;
+  if (!tab || !tab.collector || !server) {
+    picker.setSampleInterval(null);
+    return;
+  }
+  serverCatalog(server).then((catalog) => {
+    if (picker !== rangePicker || tab !== current.tab || server !== current.server) return;
+    picker.setSampleInterval(collectorIntervalFromCatalog(catalog, tab.collector));
+  });
+}
+
 /* This server's fleet card, plus the reason sentence the fleet's worst-first ranking computed for it. ONE
  * /api/fleet read serves both jobs the page has for it — the header's band and reason, and the engine the tab
  * set is chosen by — because two callers of the same endpoint on one page render is a second request nobody
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/sweeps.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/sweeps.js
index 0c6256a877..ec7429ac9b 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/sweeps.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/sweeps.js
@@ -26,6 +26,8 @@
 import { el, mount, apiGet, readTool, loadingStrip, errorStrip, emptyStrip, localTime, relTime, rollupTextId,
          fmtInt, fmtMb, fmtPct, fmtBool, fmtText, bandClass, disclosure } from "../util.js";
 import { gridTable } from "../panels.js";
+import { pageRangePicker, windowOfSpec } from "../page-range.js";
+import { relativeSpec } from "../time-range.js";
 
 /* The watch-item state vocabulary — the label each FleetSweepWatchStateMachine state owes an operator. The
    KEYS are the machine's own constants; Darling.Tests.FleetSweepWebFeedTests parses THIS OBJECT and compares
@@ -38,20 +40,15 @@ export const SWEEP_WATCH_STATE_LABELS = {
   closed: "Closed",
 };
 
-/* The configurable viewing spans. 1 hour is the DEFAULT by the owner's ruling ("configurable spans of time
-   though, default hourly") — at the shipped hourly cadence that lands the page on the newest sweep, and the
-   wider spans are the way into history. */
-const SPANS = [
-  { hours: 1, label: "Last hour" },
-  { hours: 6, label: "6 hours" },
-  { hours: 24, label: "24 hours" },
-  { hours: 72, label: "3 days" },
-  { hours: 168, label: "7 days" },
-];
+/* The viewing span is the shared time range picker's (#5562). 1 hour is the DEFAULT by the owner's ruling ("configurable
+   spans of time though, default hourly") - at the shipped hourly cadence that lands the page on the newest sweep, and the
+   wider spans are the way into history. The timeline read takes whole hours back from an end (hours, as_of) with no row
+   cap, so a shorter or finished range is fetched as the whole hours and trimmed to the exact pair in timelineSweeps. */
+const DEFAULT_SPAN_HOURS = 1;
 
 /* Page state persists across the 60s refresh (the fleet page's module-level rule): the chosen span, the
    selected sweep (null = latest), and whether the watch table is showing closed history. */
-let sweepSpanHours = 1;
+let sweepSpec = relativeSpec(DEFAULT_SPAN_HOURS * 3600000);
 let selectedSweepId = null;
 let watchStateShown = null; // null = the open + carried default view; "closed" etc. on request
 
@@ -104,15 +101,28 @@ async function renderCadence(meta) {
 }
 
 function spanControl() {
-  const sel = el("select", { class: "sort-select", "aria-label": "Timeline span" },
-    SPANS.map((s) => el("option", { value: String(s.hours), text: s.label })));
-  sel.value = String(sweepSpanHours);
-  sel.addEventListener("change", () => {
-    sweepSpanHours = Number(sel.value);
-    const mainNode = document.getElementById("main");
-    if (mainNode) renderSweeps(mainNode);
+  const { picker } = pageRangePicker({
+    read: "get_sweep_reports",
+    spec: sweepSpec,
+    label: "Timeline span",
+    /* The sweep feed is the monitoring tool's own, fed by no collector, so there is no "collected every N minutes" note. */
+    useCatalogInterval: false,
+    onChange: (spec) => {
+      sweepSpec = spec;
+      const mainNode = document.getElementById("main");
+      if (mainNode) renderSweeps(mainNode);
+    },
+  });
+  return el("div", { class: "sort-control" }, [el("span", { text: "Span" }), picker.node]);
+}
+
+/* The sweeps the held range covers, from the whole-hours fetch: those swept at or before its end and at or after its start. */
+export function timelineSweeps(sweeps, w) {
+  if (!w) return sweeps;
+  return sweeps.filter((s) => {
+    const t = Date.parse(s.swept_at);
+    return !Number.isFinite(t) || (t >= w.startMs && t <= w.endMs);
   });
-  return el("label", { class: "sort-control" }, [el("span", { text: "Span" }), sel]);
 }
 
 /* ─────────────────────────── the sweep document ─────────────────────────── */
@@ -296,10 +306,11 @@ function livenessBlock(d, lv) {
 
 async function renderTimeline(box, detailBox) {
   mount(box, loadingStrip("Loading timeline…"));
-  const res = await apiGet("/api/sweeps?hours=" + sweepSpanHours);
+  const w = windowOfSpec(sweepSpec) || windowOfSpec(relativeSpec(DEFAULT_SPAN_HOURS * 3600000));
+  const res = await apiGet("/api/sweeps?hours=" + w.hours + (w.asOf ? "&as_of=" + encodeURIComponent(w.asOf) : ""));
   if (res.kind === "error") return mount(box, errorStrip(res.message));
 
-  const sweeps = (res.data && res.data.sweeps) || [];
+  const sweeps = timelineSweeps((res.data && res.data.sweeps) || [], w);
   if (!sweeps.length) {
     mount(box, emptyStrip("No sweeps in this span. Widen the span, or check that fleet_sweep.enabled is on — a gap in this timeline is a missed sweep, with its cause on the service log."));
     return;
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/views.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/views.js
index f4004690e0..00e78424fd 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/views.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/views.js
@@ -26,6 +26,7 @@
  */
 
 import { el, mount, apiGetFleet, loadingStrip, errorStrip, emptyStrip, noticeStrip, relTime, localTime, fmtNum } from "../util.js";
+import { rollingHoursPicker } from "../page-range.js";
 import { renderPanel, setPanelSignal, VIZ } from "../panels.js";
 import { orderServers } from "../server-order.js";
 import { renderComposedPanelCard } from "../compose.js";
@@ -94,16 +95,6 @@ function viewRefreshControl(view, def, isNotebook, canEdit) {
   return control.root;
 }
 
-/** The time-range choices the rendered view's chrome offers (mirrors the composer's RANGE_OPTIONS). */
-const VIEW_RANGE_OPTIONS = [
-  { hours: 1, label: "Last hour" },
-  { hours: 6, label: "Last 6 hours" },
-  { hours: 24, label: "Last 24 hours" },
-  { hours: 24 * 7, label: "Last 7 days" },
-  { hours: 24 * 30, label: "Last 30 days" },
-  { hours: 24 * 90, label: "Last 90 days" },
-];
-
 /* ─────────────────────────── list page ─────────────────────────── */
 
 export async function renderViewList(main) {
@@ -906,88 +897,24 @@ function varControl(v, state, onChange) {
   return inp;
 }
 
-/* Mirror of the compose backend's window ceiling (ComposeLimits.MaxWindow = 90 days) — a custom range can't exceed it. */
+/* Mirror of the compose backend's window ceiling (ComposeLimits.MaxWindowHours = 90 days). The shared time range picker (#5562) greys
+   out a longer length with the reason; the old Custom number input clamped it silently. */
 const MAX_RANGE_HOURS = 24 * 90;
 
-/* A human label for an arbitrary hour count (whole days render as days), matching the preset labels' style. */
-function rangeLabel(hours) {
-  if (hours % 24 === 0 && hours >= 24) {
-    const d = hours / 24;
-    return "Last " + d + (d === 1 ? " day" : " days");
-  }
-  return "Last " + hours + (hours === 1 ? " hour" : " hours");
-}
-
-/* A time-range picker bound to state.hours: the presets, plus the view's stored default and the current value when
-   either is a non-preset custom window (kept selectable so the 60s refresh shows exactly what's applied), plus a
-   "Custom…" entry that reveals a number + unit input. The compose backend accepts any window up to MAX_RANGE_HOURS,
-   so an arbitrary span is purely this UI. */
+/* The view scope's time range: the shared picker in its rolling-only form, because the scope is "this many hours back from now" (the
+   compose runner and the read cells take hours, not an end). It is bound to state.hours; the view's stored default and the current
+   value show as the picker's label, so the 60s refresh shows exactly what is applied. */
 function buildRangeSelect(defaultHours, state, onChange) {
-  const wrap = el("span", { class: "range-select" });
-  const sel = el("select", { class: "filter-box", "aria-label": "Time range" });
-  const added = new Set(VIEW_RANGE_OPTIONS.map((r) => String(r.hours)));
-  for (const r of VIEW_RANGE_OPTIONS) sel.appendChild(el("option", { value: String(r.hours), text: r.label }));
-  for (const h of [state.hours, defaultHours]) {
-    const key = String(h);
-    if (h && !added.has(key)) {
-      sel.appendChild(el("option", { value: key, text: rangeLabel(h) }));
-      added.add(key);
-    }
-  }
-  sel.appendChild(el("option", { value: "custom", text: "Custom…" }));
-  sel.value = String(state.hours);
-
-  const custom = buildCustomHoursInput(state, onChange);
-  custom.style.display = "none";
-
-  sel.addEventListener("change", () => {
-    if (sel.value === "custom") {
-      custom.style.display = "";
-      return;
-    }
-    custom.style.display = "none";
-    state.hours = parseInt(sel.value, 10) || defaultHours;
-    onChange();
-  });
-
-  wrap.appendChild(sel);
-  wrap.appendChild(custom);
-  return wrap;
-}
-
-/* The inline custom-window input revealed by the "Custom…" range option: a number + unit (hours/days); Apply (or
-   Enter) commits it to state.hours, clamped to MAX_RANGE_HOURS, and re-runs the panels. */
-function buildCustomHoursInput(state, onChange) {
-  const box = el("span", { class: "range-custom" });
-  const num = el("input", { class: "filter-box range-custom-n", type: "number", min: "1", step: "1", "aria-label": "Custom range amount" });
-  const unit = el("select", { class: "filter-box range-custom-u", "aria-label": "Custom range unit" });
-  unit.appendChild(el("option", { value: "1", text: "hours" }));
-  unit.appendChild(el("option", { value: "24", text: "days" }));
-  if (state.hours % 24 === 0 && state.hours >= 24) {
-    num.value = String(state.hours / 24);
-    unit.value = "24";
-  } else {
-    num.value = String(state.hours);
-    unit.value = "1";
-  }
-  const apply = el("button", { class: "btn small", type: "button", text: "Apply" });
-  const commit = () => {
-    const n = parseInt(num.value, 10);
-    if (!n || n < 1) return;
-    state.hours = Math.min(n * parseInt(unit.value, 10), MAX_RANGE_HOURS);
-    onChange();
-  };
-  apply.addEventListener("click", commit);
-  num.addEventListener("keydown", (e) => {
-    if (e.key === "Enter") {
-      e.preventDefault();
-      commit();
-    }
+  const picker = rollingHoursPicker({
+    hours: state.hours || defaultHours,
+    reachHours: MAX_RANGE_HOURS,
+    label: "Time range",
+    onChange: (hours) => {
+      state.hours = hours;
+      onChange();
+    },
   });
-  box.appendChild(num);
-  box.appendChild(unit);
-  box.appendChild(apply);
-  return box;
+  return el("span", { class: "range-select" }, [picker.node]);
 }
 
 /* The server scope picker: a <details> dropdown of checkboxes — "All servers (fleet)" plus each fleet server.
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
index 04abcf5a98..c7f0c128f8 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
@@ -36,6 +36,8 @@ import {
   parseRange,
   readWindow,
   reachRefusal,
+  rollingOnlyRefusal,
+  minSpanRefusal,
   reachText,
   sampleIntervalNote,
   dataStartNote,
@@ -56,6 +58,10 @@ let pickerCount = 0;
  * @param {number|null} [opts.sampleIntervalMs] the main collector's interval; a span with fewer than 3 samples shows a note
  * @param {number|null} [opts.dataStartMs] where the data begins; a range starting well before it shows a note
  * @param {boolean} [opts.compact] hide the detail beside the button (it moves into the tooltip)
+ * @param {boolean} [opts.rollingOnly] offer only "this long back from now" (#5562 R5, the FinOps pages): no calendar periods, no
+ *   custom end, whole hours, at least one hour. A range outside that is greyed out or refused with the reason, never clamped.
+ * @param {number} [opts.minSpanMs] a floor above the global 5 minutes for a page whose read cannot answer a shorter range
+ * @param {number} [opts.stepMs] with rollingOnly, the unit a length must be a whole number of (default one hour; a daily read passes a day)
  * @param {string} [opts.label] the accessible name (default "Time range")
  * @param {(spec: object, range: object) => void} [opts.onChange] raised when the reader picks or applies a range
  */
@@ -116,10 +122,16 @@ export function timeRangePicker(opts = {}) {
     draw();
   }
 
+  /* Why this page cannot read the range, or null: past the reach, outside a rolling-only page's shape, or under its own floor. */
+  function refusalFor(next, range) {
+    const rolling = opts.rollingOnly ? rollingOnlyRefusal(next, range.spanMs, opts.minSpanMs || undefined, opts.stepMs || undefined) : null;
+    return rolling || minSpanRefusal(range.spanMs, opts.minSpanMs) || reachRefusal(range.spanMs, reach);
+  }
+
   function choose(next) {
     const r = resolveSpec(next, now(), zone);
     if (!r.ok) return r.error.message;
-    const tooLong = reachRefusal(r.range.spanMs, reach);
+    const tooLong = refusalFor(next, r.range);
     if (tooLong) return tooLong;
     hold(next);
     close(true);
@@ -130,7 +142,7 @@ export function timeRangePicker(opts = {}) {
   /* One row of the popup lists: the name, the length it is right now, and why it is greyed out when it is. */
   function item(next, nowMs) {
     const r = resolveSpec(next, nowMs, zone);
-    const why = !r.ok ? r.error.message : reachRefusal(r.range.spanMs, reach);
+    const why = !r.ok ? r.error.message : refusalFor(next, r.range);
     const selected = specId(next) === specId(spec);
     const children = [el("span", { class: "trp-item-name", text: specName(next) })];
     if (r.ok) children.push(el("span", { class: "trp-item-length", text: r.range.length }));
@@ -162,7 +174,7 @@ export function timeRangePicker(opts = {}) {
     const r = parseRange(text, nowMs, zone);
     let error = r.ok ? null : r.error;
     if (r.ok) {
-      const tooLong = reachRefusal(r.range.spanMs, reach);
+      const tooLong = refusalFor(r.spec, r.range);
       if (tooLong) error = tooLong;
     }
     if (error) {
@@ -196,7 +208,7 @@ export function timeRangePicker(opts = {}) {
   function buildPopup() {
     const nowMs = now();
     const r = current();
-    textBox = el("input", { type: "text", class: "trp-text", "aria-label": "Type a time range", "aria-describedby": previewId, placeholder: "45m, last month, Oct 1 - Oct 2", autocomplete: "off", spellcheck: "false" });
+    textBox = el("input", { type: "text", class: "trp-text", "aria-label": "Type a time range", "aria-describedby": previewId, placeholder: opts.rollingOnly ? "6h, 3d, 2w" : "45m, last month, Oct 1 - Oct 2", autocomplete: "off", spellcheck: "false" });
     preview = el("div", { class: "trp-preview", id: previewId, role: "status", "aria-live": "polite" });
     applyButton = el("button", { type: "button", class: "btn trp-apply", text: "Apply" });
     fromBox = el("input", { type: "datetime-local", class: "trp-pick", "aria-label": "Range start", step: "60" });
@@ -224,16 +236,23 @@ export function timeRangePicker(opts = {}) {
       el("div", { class: "trp-heading", text: "Calendar periods" }),
       ...CALENDAR_PRESETS.map((s) => item(s, nowMs)),
     ]);
-    const custom = el("div", { class: "trp-column trp-custom" }, [
-      el("div", { class: "trp-heading", text: "Type a range" }),
-      textBox,
-      preview,
-      el("div", { class: "trp-heading", text: "Or pick a start and an end" }),
-      el("div", { class: "trp-picks" }, [fromBox, el("span", { text: "to" }), toBox]),
-      el("div", { class: "trp-zone", text: "Times are in " + zone.replace(/_/g, " ") + "." }),
-      applyButton,
-    ]);
-    popup = el("div", { class: "trp-popup", role: "dialog", "aria-label": name + " options" }, [quick, periods, custom]);
+    /* A rolling-only page (#5562 R5) has no calendar periods and no start-and-end pick: its reads are "hours back from now". */
+    const custom = el(
+      "div",
+      { class: "trp-column trp-custom" },
+      opts.rollingOnly
+        ? [el("div", { class: "trp-heading", text: "Type a length" }), textBox, preview, applyButton]
+        : [
+            el("div", { class: "trp-heading", text: "Type a range" }),
+            textBox,
+            preview,
+            el("div", { class: "trp-heading", text: "Or pick a start and an end" }),
+            el("div", { class: "trp-picks" }, [fromBox, el("span", { text: "to" }), toBox]),
+            el("div", { class: "trp-zone", text: "Times are in " + zone.replace(/_/g, " ") + "." }),
+            applyButton,
+          ]
+    );
+    popup = el("div", { class: "trp-popup", role: "dialog", "aria-label": name + " options" }, opts.rollingOnly ? [quick, custom] : [quick, periods, custom]);
     popup.addEventListener("keydown", (e) => {
       if (e.key === "Escape") {
         e.stopPropagation();
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
index 8020057033..95b35b4def 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
@@ -867,6 +867,30 @@ export function reachRefusal(spanMs, hours) {
   return spanMs > hours * HOUR_MS ? "This page's reads reach at most " + reachText(hours) + " back." : null;
 }
 
+/** The shortest range a rolling-only page offers: one hour, because its reads take whole hours back from now (#5562 R5). */
+export const ROLLING_ONLY_MIN_SPAN_MS = HOUR_MS;
+
+/**
+ * The reason a range is not one a rolling-only page can read, or null (#5562 R5). A FinOps read is "this many hours back from
+ * now", so it cannot honor a calendar period, a finished range, a since-range or a length that is not a whole number of hours;
+ * the page refuses them rather than showing a range its read would answer differently.
+ */
+export function rollingOnlyRefusal(spec, spanMs, minSpanMs = ROLLING_ONLY_MIN_SPAN_MS, stepMs = HOUR_MS) {
+  if (!spec || spec.kind !== "relative") {
+    return "This page reads a length back from now, so pick a rolling length such as 24h or 7d.";
+  }
+  if (spanMs < minSpanMs) return "This page reads at least " + formatLength(minSpanMs) + " back from now.";
+  if (spanMs % stepMs !== 0) {
+    return stepMs % DAY_MS === 0 ? "This page reads whole days back from now, such as 7d or 30d." : "This page reads whole hours back from now, such as 6h or 3d.";
+  }
+  return null;
+}
+
+/** The reason a range is shorter than a page's own floor, or null. */
+export function minSpanRefusal(spanMs, minSpanMs) {
+  return minSpanMs > 0 && spanMs < minSpanMs ? "This page reads at least " + formatLength(minSpanMs) + "." : null;
+}
+
 /**
  * The window a read takes for a resolved range: reads take whole `hours` and an `as_of` end. `hours` rounds the span UP to a whole
  * number of hours (at least 1), so the fetch starts at or before the range start and the page trims to the exact pair; `asOf` is

From eaa6e84966c460c219875e6cb412fc9b5c3d82aa Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:22:32 -0400
Subject: [PATCH 11/33] Page tests and harnesses drive the shared picker; new
 WebPageRangeTests cover the rolling-only rule, the job and sweep ends and the
 server page note (#5562)

---
 .../AlertHistoryRangePageTests.cs             |  33 ++-
 Darling/Darling.Tests/FinOpsPageShellTests.cs |   3 +-
 ...FinOpsStorageGrowthWindowBehaviourTests.cs |  17 +-
 .../FinOpsTabDatabaseResourcesPageTests.cs    |  10 +-
 .../FinOpsTabHighImpactPageTests.cs           |   8 +-
 .../FinOpsTabOptimizationPageTests.cs         |   8 +-
 .../FinOpsTabStorageGrowthPageTests.cs        |   2 +-
 .../FinOpsWindowPickerBehaviourTests.cs       |  17 +-
 Darling/Darling.Tests/JobHistoryPageTests.cs  |  45 +++-
 Darling/Darling.Tests/WebPageRangeTests.cs    | 205 ++++++++++++++++++
 .../alert-history-range-harness.mjs           |  20 +-
 .../finops-storage-growth-window-harness.mjs  |  31 +--
 .../finops-window-picker-harness.mjs          |  22 +-
 Darling/Darling.Tests/job-history-harness.mjs |  39 +++-
 Darling/Darling.Tests/page-range-harness.mjs  |  86 ++++++++
 Darling/Darling.Tests/web-picker-driver.mjs   |  78 +++++++
 16 files changed, 557 insertions(+), 67 deletions(-)
 create mode 100644 Darling/Darling.Tests/WebPageRangeTests.cs
 create mode 100644 Darling/Darling.Tests/page-range-harness.mjs
 create mode 100644 Darling/Darling.Tests/web-picker-driver.mjs

diff --git a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
index b2b3984a36..f2424232f4 100644
--- a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
+++ b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
@@ -33,7 +33,10 @@ public void ThePageReadsGetAlertHistoryWithTheFourChoicesAndNeverAFixedWindow()
         Assert.DoesNotContain("hours_back: 24", page);
         Assert.DoesNotContain("limit: 200 }", page);
         Assert.Contains("readTool(\"get_alert_history\", readParams())", page);
-        Assert.Contains("hours_back: choices.hours", page);
+        // #5562: the range is the shared picker's spec, read as of each read; a finished range also sends its end.
+        Assert.Contains("const w = windowOfSpec(choices.spec);", page);
+        Assert.Contains("hours_back: w ? w.hours : DEFAULT_HOURS", page);
+        Assert.Contains("as_of: w ? w.asOf : null", page);
         Assert.Contains("limit: choices.limit", page);
         Assert.Contains("server_name: choices.server || null", page);
         Assert.Contains("include_dismissed: choices.dismissed ? \"true\" : null", page);
@@ -45,9 +48,14 @@ public void ThePageReadsGetAlertHistoryWithTheFourChoicesAndNeverAFixedWindow()
     public void NoWindowOrLimitIsOfferedThatTheToolOrTheDispatchLayerRefuses()
     {
         var page = Page();
-        var hours = System.Text.RegularExpressions.Regex.Matches(page, "\\{ hours: (\\d+), label").Select(m => int.Parse(m.Groups[1].Value)).ToList();
-        Assert.Equal(new[] { 1, 4, 24, 168 }, hours);
-        Assert.True(hours.Max() <= PerformanceMonitor.Common.McpHelpers.MaxHoursBack);
+        // #5562 R8: no hand-listed windows and no "All". The picker takes its reach from the catalog's max_hours for the read, which is
+        // the 168 hours the read's validator accepts, so a longer range is greyed out with the reason and never clamped. The alert table
+        // keeps 90 days (AlertHistoryRetentionDays, DarlingRetention.cs), but the web read stops at the common reach (R2).
+        Assert.DoesNotContain("WINDOW_CHOICES", page);
+        Assert.Contains("read: \"get_alert_history\"", page);
+        Assert.Contains("pageRangePicker({", page);
+        Assert.Equal(PerformanceMonitor.Common.McpHelpers.MaxHoursBack, PerformanceMonitor.Darling.Service.WebReadReach.All["get_alert_history"].MaxHours);
+        Assert.Equal(90, PerformanceMonitor.Darling.Storage.DarlingRetentionHorizons.AlertHistoryRetentionDays);
 
         var limits = System.Text.RegularExpressions.Regex.Match(page, "const LIMIT_CHOICES = \\[([0-9, ]+)\\]").Groups[1].Value
             .Split(',').Select(s => int.Parse(s.Trim())).ToList();
@@ -118,7 +126,15 @@ public void EachChoiceReachesTheRead()
         Assert.Equal("1000", Get(dismissed, "limit"));
         Assert.Equal("srv-b", Get(dismissed, "server_name"));
 
-        Assert.Equal("1,4,24,168", string.Join(",", r.GetProperty("windowOptions").EnumerateArray().Select(e => e.GetString())));
+        // The popup offers the short presets and the calendar periods within 7 days; the longer ones are greyed out, never clamped.
+        Assert.Equal("Past 5 minutes,Past 15 minutes,Past 30 minutes,Past hour,Past 4 hours,Past day,Past 2 days,Past week,Today,Yesterday,Week to Date,Previous Week",
+            string.Join(",", r.GetProperty("windowOptions").EnumerateArray().Select(e => e.GetString())));
+        Assert.Equal("Past 30 days,Month to Date,Previous Month,Year to Date,Previous Year",
+            string.Join(",", r.GetProperty("windowGreyed").EnumerateArray().Select(e => e.GetString())));
+        Assert.Equal("This page's reads reach at most 7 days back.", r.GetProperty("refused").GetString());
+        // A finished range sends its end as as_of; a shorter-than-an-hour range reads the whole hour.
+        Assert.EndsWith("Z", Get(r.GetProperty("finished"), "as_of"));
+        Assert.Equal("1", Get(r.GetProperty("thirtyMinutes"), "hours_back"));
         Assert.Equal("200,500,1000", string.Join(",", r.GetProperty("limitOptions").EnumerateArray().Select(e => e.GetString())));
         Assert.Equal(",srv-a,srv-b", string.Join(",", r.GetProperty("serverOptions").EnumerateArray().Select(e => e.GetString())));
     }
@@ -138,7 +154,7 @@ public void TheChoicesSurviveThePollAndAVisitElsewhere()
         }
 
         var shown = r.GetProperty("shown");
-        Assert.Equal("4", shown.GetProperty("window").GetString());
+        Assert.Equal("Past 4 hours", shown.GetProperty("window").GetString());
         Assert.Equal("500", shown.GetProperty("limit").GetString());
         Assert.Equal("srv-a", shown.GetProperty("server").GetString());
         Assert.True(shown.GetProperty("dismissed").GetBoolean());
@@ -184,7 +200,10 @@ public void TwoServersThatShareADisplayNameKeepBothRows()
     [Fact]
     public void TheRangePickerSaysTheWebReadsAtMostSevenDays()
     {
-        Assert.Contains("The web reads at most 7 days", Page());
+        // #5562: the picker greys out what the read cannot reach and says why (the catalog's max_hours), so the page needs no hand-written
+        // "at most 7 days" tooltip; the reach is the read's own 168 hours.
+        Assert.DoesNotContain("The web reads at most 7 days of alert history, so there is no All choice.", Page());
+        Assert.Contains("the web read stops at the common 7 day reach", Page());
     }
 
     [Fact]
diff --git a/Darling/Darling.Tests/FinOpsPageShellTests.cs b/Darling/Darling.Tests/FinOpsPageShellTests.cs
index 52269a4a3b..abe1fbb7ac 100644
--- a/Darling/Darling.Tests/FinOpsPageShellTests.cs
+++ b/Darling/Darling.Tests/FinOpsPageShellTests.cs
@@ -168,7 +168,8 @@ public void EveryTabFile_ExportsTabWithIdLabelBuild_AndTheIdIsTheFileName()
             .Select(Path.GetFileNameWithoutExtension)
             // database-box.js is the shared Database box the Index Analysis and Locking tabs import (#5231), not a tab.
             // gate.js is the helper the tabs share for their empty and not-collected states on a PostgreSQL target, also not a tab.
-            .Where(name => name != "database-box" && name != "gate")
+            // window.js is the rolling-only time range picker the windowed tabs share (#5562), also not a tab.
+            .Where(name => name != "database-box" && name != "gate" && name != "window")
             .OrderBy(x => x, StringComparer.Ordinal).ToArray();
         Assert.Equal(TabIds.OrderBy(x => x, StringComparer.Ordinal).ToArray(), onDisk);
 
diff --git a/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs b/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
index 430c977cb3..02454ee9e0 100644
--- a/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
+++ b/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
@@ -84,13 +84,18 @@ public void TheObjectsLevelDefaultsToThirtyDays_AndEachPickSendsDaysTimes24()
         var run = Run();
         var objects = run.GetProperty("objects");
         Assert.Equal(new[] { "720" }, Hours(objects));
-        Assert.Equal("7,30,90", string.Join(",", objects.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
-        Assert.Equal("30", objects.GetProperty("value").GetString());
+        // #5562 R5: the Compact rolling-only picker, whole days, reach 2160 hours for this view (not the catalog entry's 168).
+        Assert.Equal("Past day,Past 2 days,Past week,Past 30 days", string.Join(",", objects.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
+        var refused = objects.GetProperty("refused");
+        Assert.Equal("This page reads whole days back from now, such as 7d or 30d.", refused.GetProperty("hours").GetString());
+        Assert.Equal("This page reads a length back from now, so pick a rolling length such as 24h or 7d.", refused.GetProperty("calendar").GetString());
+        Assert.Equal("This page's reads reach at most 90 days back.", refused.GetProperty("tooLong").GetString());
+        Assert.Equal("Past 30 days", objects.GetProperty("value").GetString());
 
         Assert.Equal(new[] { "2160" }, Hours(run.GetProperty("picked90")));
-        Assert.Equal("90", run.GetProperty("picked90").GetProperty("value").GetString());
+        Assert.Equal("Past 90 days", run.GetProperty("picked90").GetProperty("value").GetString());
         Assert.Equal(new[] { "168" }, Hours(run.GetProperty("picked7")));
-        Assert.Equal("7", run.GetProperty("picked7").GetProperty("value").GetString());
+        Assert.Equal("Past week", run.GetProperty("picked7").GetProperty("value").GetString());
     }
 
     [Fact]
@@ -99,11 +104,11 @@ public void ThePickSurvivesARebuildForTheSameServer_AndAnotherServerStartsAtThir
         var run = Run();
         var rebuilt = run.GetProperty("rebuilt");
         Assert.Equal(new[] { "168" }, Hours(rebuilt));
-        Assert.Equal("7", rebuilt.GetProperty("value").GetString());
+        Assert.Equal("Past week", rebuilt.GetProperty("value").GetString());
 
         Assert.Equal(new[] { "24" }, Hours(run.GetProperty("other")));
         var otherObjects = run.GetProperty("otherObjects");
         Assert.Equal(new[] { "720" }, Hours(otherObjects));
-        Assert.Equal("30", otherObjects.GetProperty("value").GetString());
+        Assert.Equal("Past 30 days", otherObjects.GetProperty("value").GetString());
     }
 }
diff --git a/Darling/Darling.Tests/FinOpsTabDatabaseResourcesPageTests.cs b/Darling/Darling.Tests/FinOpsTabDatabaseResourcesPageTests.cs
index 5052aac8bd..06b2fe1a43 100644
--- a/Darling/Darling.Tests/FinOpsTabDatabaseResourcesPageTests.cs
+++ b/Darling/Darling.Tests/FinOpsTabDatabaseResourcesPageTests.cs
@@ -36,18 +36,16 @@ public void TheTabReadsGetFinOpsWithTheDatabaseResourcesViewWindow()
     [Fact]
     public void ThePickerOffersTheDesktopWindowsInOrder()
     {
-        // Source: FinOpsTab.xaml ~:497-499, FinOpsResourceUsageTimeRangeCombo.
+        // #5562 R5: the shared picker in its Compact, rolling-only form (finops/window.js), not a hand-listed select.
         var tab = Tab();
-        var pairs = Regex.Matches(tab, "\\{ value: (\\d+), label: \"([^\"]+)\" \\}").Select(m => m.Groups[1].Value + "=" + m.Groups[2].Value);
-        Assert.Equal("1=Last 1 hour,4=Last 4 hours,12=Last 12 hours,24=Last 24 hours,168=Last 7 days", string.Join(",", pairs));
-        Assert.Contains("pickerControl(\"Window\", WINDOWS, HOURS,", tab);
+        Assert.DoesNotContain("WINDOWS", tab);
+        Assert.Contains("finopsWindowControl({ hours: HOURS, onChange: (hours) => load(hours) })", tab);
     }
 
     [Fact]
     public void TheChangeHandlerRereadsWithTheChosenHoursAndTheFirstReadUsesTheDefault()
     {
         var tab = Tab();
-        Assert.Contains("sel.addEventListener(\"change\", () => onPick(Number(sel.value)));", tab);
         Assert.Contains("(hours) => load(hours)", tab);
         Assert.Contains("load(HOURS);", tab);
     }
@@ -127,7 +125,7 @@ public void TheTabImportsOnlyTheSharedHelpers()
     {
         var imports = Regex.Matches(Tab(), "from \"([^\"]+)\";").Select(m => m.Groups[1].Value).ToList();
         Assert.NotEmpty(imports);
-        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../charts.js", "../../util.js", "./gate.js" }));
+        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../charts.js", "../../util.js", "./gate.js", "./window.js" }));
         Assert.Contains("./gate.js", imports);
     }
 
diff --git a/Darling/Darling.Tests/FinOpsTabHighImpactPageTests.cs b/Darling/Darling.Tests/FinOpsTabHighImpactPageTests.cs
index 39ecedc0d4..3edf9a168a 100644
--- a/Darling/Darling.Tests/FinOpsTabHighImpactPageTests.cs
+++ b/Darling/Darling.Tests/FinOpsTabHighImpactPageTests.cs
@@ -34,9 +34,9 @@ public void TheTabReadsGetFinOpsWithTheHighImpactViewWindowAndLimit()
     public void ThePickerOffersTheDesktopWindowsAndTheStateIsKeptPerServer()
     {
         var tab = Tab();
-        var pairs = Regex.Matches(tab, "\\{ value: (\\d+), label: \"([^\"]+)\" \\}").Select(m => m.Groups[1].Value + "=" + m.Groups[2].Value);
-        Assert.Equal("1=Last 1 hour,4=Last 4 hours,12=Last 12 hours,24=Last 24 hours,168=Last 7 days", string.Join(",", pairs));
-        Assert.Contains("pickerControl(\"Window\", WINDOWS, start,", tab);
+        // #5562 R5: the shared picker in its Compact, rolling-only form (finops/window.js), not a hand-listed select.
+        Assert.DoesNotContain("WINDOWS", tab);
+        Assert.Contains("finopsWindowControl({ hours: start, onChange: (hours) => load(hours) })", tab);
         Assert.Contains("const chosenHours = new Map();", tab);
         Assert.Contains("chosenHours.set(server, hours);", tab);
         Assert.Contains("chosenHours.get(server) ?? HOURS", tab);
@@ -77,7 +77,7 @@ public void TheTabImportsOnlyTheSharedHelpers()
     {
         var imports = Regex.Matches(Tab(), "from \"([^\"]+)\";").Select(m => m.Groups[1].Value).ToList();
         Assert.NotEmpty(imports);
-        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../charts.js", "../../util.js", "../plan-viewer.js", "./gate.js" }));
+        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../charts.js", "../../util.js", "../plan-viewer.js", "./gate.js", "./window.js" }));
         Assert.Contains("./gate.js", imports);
     }
 
diff --git a/Darling/Darling.Tests/FinOpsTabOptimizationPageTests.cs b/Darling/Darling.Tests/FinOpsTabOptimizationPageTests.cs
index 9fdfc9db71..7131a46578 100644
--- a/Darling/Darling.Tests/FinOpsTabOptimizationPageTests.cs
+++ b/Darling/Darling.Tests/FinOpsTabOptimizationPageTests.cs
@@ -66,9 +66,9 @@ private static void AssertKeysMatchRow(string constName, string method, string c
     public void ThePickerOffersTheDesktopWindowsAndTheStateIsKeptPerServer()
     {
         var tab = Tab();
-        var pairs = Regex.Matches(tab, "\\{ value: (\\d+), label: \"([^\"]+)\" \\}").Select(m => m.Groups[1].Value + "=" + m.Groups[2].Value);
-        Assert.Equal("1=Last 1 hour,4=Last 4 hours,12=Last 12 hours,24=Last 24 hours,168=Last 7 days", string.Join(",", pairs));
-        Assert.Contains("pickerControl(\"Window\", WINDOWS, start,", tab);
+        // #5562 R5: the shared picker in its Compact, rolling-only form (finops/window.js), not a hand-listed select.
+        Assert.DoesNotContain("WINDOWS", tab);
+        Assert.Contains("finopsWindowControl({ hours: start, onChange: (hours) => load(hours) })", tab);
         Assert.Contains("const chosenHours = new Map();", tab);
         Assert.Contains("chosenHours.set(server, hours);", tab);
         Assert.Contains("chosenHours.get(server) ?? HOURS", tab);
@@ -188,7 +188,7 @@ public void TheTabImportsOnlyTheSharedHelpers()
     {
         var imports = Regex.Matches(Tab(), "from \"([^\"]+)\";").Select(m => m.Groups[1].Value).ToList();
         Assert.NotEmpty(imports);
-        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../charts.js", "../../util.js", "../plan-viewer.js", "./gate.js" }));
+        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../charts.js", "../../util.js", "../plan-viewer.js", "./gate.js", "./window.js" }));
         Assert.Contains("./gate.js", imports);
     }
 
diff --git a/Darling/Darling.Tests/FinOpsTabStorageGrowthPageTests.cs b/Darling/Darling.Tests/FinOpsTabStorageGrowthPageTests.cs
index ecba0fd6b0..bc802db473 100644
--- a/Darling/Darling.Tests/FinOpsTabStorageGrowthPageTests.cs
+++ b/Darling/Darling.Tests/FinOpsTabStorageGrowthPageTests.cs
@@ -254,7 +254,7 @@ public void TheTabImportsOnlyWhatItUses()
     {
         var tab = Tab();
         var imports = Regex.Matches(tab, "from \"([^\"]+)\";").Select(m => m.Groups[1].Value).ToList();
-        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../util.js", "./gate.js" }));
+        Assert.All(imports, i => Assert.Contains(i, new[] { "../../panels.js", "../../util.js", "./gate.js", "./window.js" }));
         Assert.Contains("./gate.js", imports);
         var names = Regex.Match(tab, "import \\{([^}]*)\\} from \"../../util.js\"").Groups[1].Value.Split(',').Select(n => n.Trim());
         var body = tab.Substring(tab.IndexOf("const HOURS", System.StringComparison.Ordinal));
diff --git a/Darling/Darling.Tests/FinOpsWindowPickerBehaviourTests.cs b/Darling/Darling.Tests/FinOpsWindowPickerBehaviourTests.cs
index ae82b5c167..6d1c382625 100644
--- a/Darling/Darling.Tests/FinOpsWindowPickerBehaviourTests.cs
+++ b/Darling/Darling.Tests/FinOpsWindowPickerBehaviourTests.cs
@@ -67,22 +67,31 @@ public void ThePickKeepsAcrossARebuildForTheSameServerAndResetsForAnother(string
 
         var first = t.GetProperty("first");
         Assert.Equal(new[] { "24" }, Hours(first));
-        Assert.Equal("1,4,12,24,168", string.Join(",", first.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
+        // #5562 R5: the shared picker in its Compact, rolling-only form. Every FinOps read is hours back from now, so it offers
+        // no calendar period and no start-and-end boxes, nothing under an hour, and no length past the read's 7 day reach.
+        Assert.Equal("Past hour,Past 4 hours,Past day,Past 2 days,Past week", string.Join(",", first.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
+        Assert.Equal("Quick ranges,Type a length", string.Join(",", first.GetProperty("shape").GetProperty("headings").EnumerateArray().Select(e => e.GetString())));
+        Assert.Equal(0, first.GetProperty("shape").GetProperty("dateBoxes").GetInt32());
+        var refused = first.GetProperty("refused");
+        Assert.Equal("This page reads at least 1h back from now.", refused.GetProperty("subHour").GetString());
+        Assert.Equal("This page reads a length back from now, so pick a rolling length such as 24h or 7d.", refused.GetProperty("calendar").GetString());
+        Assert.Equal("This page reads whole hours back from now, such as 6h or 3d.", refused.GetProperty("fractional").GetString());
+        Assert.Equal("This page's reads reach at most 7 days back.", refused.GetProperty("tooLong").GetString());
 
         // A pick reads again with the chosen hours.
         var picked = t.GetProperty("picked");
         Assert.Equal(new[] { "24", "4" }, Hours(picked));
-        Assert.Equal("4", picked.GetProperty("select").GetString());
+        Assert.Equal("Past 4 hours", picked.GetProperty("select").GetString());
 
         // The poll rebuilds the tab: same server, same window, one read with it.
         var rebuilt = t.GetProperty("rebuilt");
         Assert.Equal(new[] { "4" }, Hours(rebuilt));
-        Assert.Equal("4", rebuilt.GetProperty("select").GetString());
+        Assert.Equal("Past 4 hours", rebuilt.GetProperty("select").GetString());
 
         // Another server starts at the default.
         var other = t.GetProperty("other");
         Assert.Equal(new[] { "24" }, Hours(other));
-        Assert.Equal("24", other.GetProperty("select").GetString());
+        Assert.Equal("Past day", other.GetProperty("select").GetString());
     }
 
     [Fact]
diff --git a/Darling/Darling.Tests/JobHistoryPageTests.cs b/Darling/Darling.Tests/JobHistoryPageTests.cs
index 869e847134..458dda8aea 100644
--- a/Darling/Darling.Tests/JobHistoryPageTests.cs
+++ b/Darling/Darling.Tests/JobHistoryPageTests.cs
@@ -55,7 +55,9 @@ public void EveryParameterThePageSendsIsOneTheToolTakes()
         var aliases = new System.Collections.Generic.Dictionary<string, string> { ["hours"] = "hours_back", ["server"] = "server_name" };
         foreach (var name in sent)
             Assert.Contains(aliases.TryGetValue(name, out var mapped) ? mapped : name, tool);
-        Assert.Contains("const p = { hours: state.hours, limit: state.limit };", Page());
+        // #5562: the held range gives the hours, and a finished range also sends its end as as_of.
+        Assert.Contains("const p = { hours: w.hours, limit: state.limit };", Page());
+        Assert.Contains("if (w.asOf) p.as_of = w.asOf;", Page());
     }
 
     [Fact]
@@ -156,6 +158,47 @@ public void TheFirstBuildReadsTheFleetWithTheDefaultsAndTheDesktopColumns()
         Assert.Contains("<b>boom</b>", first.GetProperty("text").GetString());
     }
 
+    [Fact]
+    public void TheRangeIsTheSharedPicker_AFinishedRangeSendsItsEnd_AndALongerOneIsRefusedNotClamped()
+    {
+        var range = Run().GetProperty("range");
+
+        // Past the catalog's 7 day reach: refused with the reason, and no read goes out (nothing is clamped).
+        Assert.Equal("This page's reads reach at most 7 days back.", range.GetProperty("past30d").GetString());
+        Assert.Equal(0, range.GetProperty("past30dCalls").GetInt32());
+
+        // A rolling length reads whole hours back from now and sends no as_of.
+        var rolling = Assert.Single(range.GetProperty("twoHours").GetProperty("calls").EnumerateArray());
+        Assert.Equal("2", rolling.GetProperty("hours").GetString());
+        Assert.False(rolling.TryGetProperty("as_of", out _));
+
+        // A finished range (yesterday) sends its end: the reader bounds the runs by it before the row limit.
+        var finished = Assert.Single(range.GetProperty("yesterday").GetProperty("calls").EnumerateArray());
+        Assert.InRange(int.Parse(finished.GetProperty("hours").GetString()!), 23, 25);
+        Assert.EndsWith("Z", finished.GetProperty("as_of").GetString());
+
+        // 30 minutes is read as the whole hour and cut at its start: the 50 minute old run goes, the 5 minute old one stays.
+        var half = range.GetProperty("thirtyMinutes");
+        Assert.Equal("1", Assert.Single(half.GetProperty("calls").EnumerateArray()).GetProperty("hours").GetString());
+        Assert.Equal("1 runs shown", Strings(half.GetProperty("shown")).Single());
+
+        // The popup greys out what the read cannot reach, and still offers the calendar periods and the end boxes.
+        Assert.Equal("Past 30 days,Month to Date,Previous Month,Year to Date,Previous Year", string.Join(",", Strings(range.GetProperty("items"))));
+        Assert.Equal(2, range.GetProperty("shape").GetProperty("dateBoxes").GetInt32());
+    }
+
+    [Fact]
+    public void TheReaderBoundsTheRunsByTheEndBeforeTheRowLimit()
+    {
+        // R6: the end is applied in SQL (JobHistoryFilter.UntilUtc), inside the per-server top-N, and again exactly in C# before the cap.
+        var reader = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Storage", "DarlingJobHistoryReader.cs").ReplaceLineEndings("\n");
+        Assert.Contains("AND   jh.run_datetime <= ${UntilParam(firstParam)} + make_interval(mins => so.offset_minutes)", reader);
+        Assert.Contains("return ApplyWindow(rows, sinceUtc, limit, filter?.UntilUtc);", reader);
+        var tool = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "Mcp", "DarlingMcpJobTools.cs").ReplaceLineEndings("\n");
+        Assert.Contains("windowEnd);", tool);
+        Assert.Contains("DarlingJobHistoryReader.GetAsync(", tool);
+    }
+
     [Fact]
     public void TheFiltersReachTheReadAndSurviveARebuild()
     {
diff --git a/Darling/Darling.Tests/WebPageRangeTests.cs b/Darling/Darling.Tests/WebPageRangeTests.cs
new file mode 100644
index 0000000000..58b0b44ee3
--- /dev/null
+++ b/Darling/Darling.Tests/WebPageRangeTests.cs
@@ -0,0 +1,205 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using PerformanceMonitor.Collectors;
+using Xunit;
+using static Darling.Tests.RepoFile;
+
+namespace Darling.Tests;
+
+/// <summary>
+/// The other nine web pages on the shared time range picker (#5562, lane L2b): the Alert History, Fleet Sweeps, Job History,
+/// FinOps (Database Resources, High Impact, Optimization, Storage Growth), Custom Views and view-editor pages, and the server
+/// page's "collected every N minutes" note. Source pins plus a Node run of the pure parts (skipped without Node).
+/// </summary>
+public sealed class WebPageRangeTests
+{
+    private static string Js(params string[] parts) =>
+        ReadRepoFile(new[] { "Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js" }.Concat(parts).ToArray()).ReplaceLineEndings("\n");
+
+    private static bool TryRunNode(out JsonElement result)
+    {
+        result = default;
+        var psi = new ProcessStartInfo("node") { RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false };
+        psi.ArgumentList.Add(PathTo("Darling", "Darling.Tests", "page-range-harness.mjs"));
+        psi.ArgumentList.Add(PathTo("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js"));
+        Process proc;
+        try
+        {
+            proc = Process.Start(psi)!;
+        }
+        catch (Win32Exception)
+        {
+            Assert.Skip("Node is not installed, so the shipped page script cannot be run.");
+            return false;
+        }
+
+        using (proc)
+        {
+            var error = proc.StandardError.ReadToEndAsync();
+            var output = proc.StandardOutput.ReadToEnd().Trim();
+            if (!proc.WaitForExit(30000))
+            {
+                proc.Kill(entireProcessTree: true);
+                Assert.Fail("the page-range harness did not finish in 30 s");
+            }
+
+            Assert.True(proc.ExitCode == 0, "the page-range harness failed: " + error.Result);
+            using var doc = JsonDocument.Parse(output);
+            result = doc.RootElement.Clone();
+            return true;
+        }
+    }
+
+    [Fact]
+    public void EveryFinOpsTabPicksItsWindowOnTheRollingOnlyPicker_NotASelect()
+    {
+        // R5: Compact, rolling-only, no calendar period, no custom end, an hour at least.
+        var window = Js("pages", "finops", "window.js");
+        Assert.Contains("compact: true,", window);
+        Assert.Contains("rollingOnly: true,", window);
+        Assert.Contains("minSpanMs: opts.minSpanMs || ROLLING_ONLY_MIN_SPAN_MS", window);
+        Assert.Contains("read: \"get_finops\"", window);
+        foreach (var tab in new[] { "database-resources", "high-impact", "optimization", "storage-growth" })
+        {
+            var src = Js("pages", "finops", tab + ".js");
+            Assert.Contains("finopsWindowControl(", src);
+            Assert.DoesNotContain("WINDOWS", src);
+            Assert.DoesNotContain("range-select-inline", src);
+        }
+    }
+
+    [Fact]
+    public void TheStorageGrowthPickerTakesTheViewsOwnReachAndWholeDays()
+    {
+        var src = Js("pages", "finops", "storage-growth.js");
+        Assert.Contains("const STORAGE_GROWTH_REACH_HOURS = 2160;", src);
+        Assert.Contains("reachHours: STORAGE_GROWTH_REACH_HOURS,", src);
+        Assert.Contains("minSpanMs: DAY_MS,", src);
+        Assert.Contains("stepMs: DAY_MS,", src);
+
+        // The reach is the view's, as the tool's own description says; the get_finops catalog entry says 168 for its other views.
+        var tool = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "Mcp", "DarlingMcpFinOpsTools.cs");
+        Assert.Contains("storage_growth: max 2160", tool);
+    }
+
+    [Fact]
+    public void ViewsAndTheEditorTakeTheirRangeFromTheRollingPicker_AndNothingIsClamped()
+    {
+        var views = Js("pages", "views.js");
+        Assert.Contains("rollingHoursPicker({", views);
+        Assert.Contains("reachHours: MAX_RANGE_HOURS,", views);
+        Assert.Contains("const MAX_RANGE_HOURS = 24 * 90;", views);
+        Assert.DoesNotContain("Math.min(n * parseInt(unit.value, 10), MAX_RANGE_HOURS)", views);
+        Assert.DoesNotContain("VIEW_RANGE_OPTIONS", views);
+
+        // The view's default range is the editor's "view default": the compose runner's 90 days, refused beyond.
+        var editor = Js("editor.js");
+        Assert.Contains("rollingHoursPicker({", editor);
+        Assert.Contains("reachHours: MAX_VIEW_RANGE_HOURS,", editor);
+        Assert.Contains("const MAX_VIEW_RANGE_HOURS = 24 * 90;", editor);
+        Assert.DoesNotContain("aria-label\": \"Default time range\" });\n  rangeSel.appendChild", editor);
+    }
+
+    [Fact]
+    public void SweepsAndJobHistorySendTheEndOfAFinishedRange()
+    {
+        var sweeps = Js("pages", "sweeps.js");
+        Assert.Contains("\"&as_of=\" + encodeURIComponent(w.asOf)", sweeps);
+        Assert.Contains("read: \"get_sweep_reports\"", sweeps);
+        Assert.DoesNotContain("SPANS", sweeps);
+
+        var jobs = Js("pages", "job-history.js");
+        Assert.Contains("read: \"get_job_history\"", jobs);
+        Assert.Contains("if (w.asOf) p.as_of = w.asOf;", jobs);
+        Assert.DoesNotContain("WINDOWS", jobs);
+    }
+
+    [Fact]
+    public void EveryServerTabThatDeclaresACollectorNamesARealOne_AndTheViewerAgreesOnTheSharedTabs()
+    {
+        var tabs = Js("pages", "server-tabs.js");
+        var declared = Regex.Matches(tabs, "(?m)^    id: \"([a-z-]+)\",\n    label: \"([^\"]+)\",\n    collector: \"([a-z_]+)\",").Select(m => (m.Groups[2].Value, m.Groups[3].Value)).ToList();
+        Assert.Equal(9, declared.Count);
+
+        foreach (var (_, collector) in declared)
+            Assert.True(CollectorScheduleDefaults.All.ContainsKey(collector), collector + " is not a collector the schedule knows");
+
+        // The SQL Server tabs the Viewer also has name the same main collector (the Viewer's table: ViewerTimeRangeWindow.MainCollectorFor).
+        foreach (var (label, collector) in declared.Take(7))
+        {
+            var viewer = PerformanceMonitor.Darling.Viewer.ViewerTimeRangeWindow.MainCollectorFor(label);
+            Assert.Equal(viewer, collector);
+        }
+    }
+
+    [Fact]
+    public void TheServerPageGivesThePickerTheTabsActualCollectorInterval_AndNeverWidensTheRange()
+    {
+        var server = Js("pages", "server.js");
+        Assert.Contains("serverCatalog(server).then((catalog) => {", server);
+        Assert.Contains("picker.setSampleInterval(collectorIntervalFromCatalog(catalog, tab.collector));", server);
+        // The note is set before the keep-the-panels return, so a poll that keeps the grid still gets it.
+        Assert.True(server.IndexOf("  applySampleNote();", StringComparison.Ordinal) < server.IndexOf("if (keepGrid) {", StringComparison.Ordinal));
+        // The server's own schedule: the catalog is asked for this server.
+        Assert.Contains("\"/api/catalog?server=\" + encodeURIComponent(server)", Js("page-range.js"));
+    }
+
+    [Fact]
+    public void ThePureParts_RunUnderNode()
+    {
+        if (!TryRunNode(out var r)) return;
+
+        // The interval is the catalog's own (a per-server schedule row over the default), and a collector it does not know gives none.
+        var interval = r.GetProperty("interval");
+        Assert.Equal(1, interval.GetProperty("waitStatsDefault").GetInt32());
+        Assert.Equal(5, interval.GetProperty("waitStatsServerOverride").GetInt32());
+        Assert.Equal(JsonValueKind.Null, interval.GetProperty("unknownCollector").ValueKind);
+        Assert.Equal(JsonValueKind.Null, interval.GetProperty("noCollector").ValueKind);
+        Assert.Equal(JsonValueKind.Null, interval.GetProperty("noCatalog").ValueKind);
+
+        // Fewer than 3 samples at the interval: the one-line note. 3 or more: none.
+        var note = r.GetProperty("note");
+        Assert.Equal("Data here is collected every 5 minutes.", note.GetProperty("fiveMinutesAtFive").GetString());
+        Assert.Equal("Data here is collected every 5 minutes.", note.GetProperty("fourteenMinutesAtFive").GetString());
+        Assert.Equal(JsonValueKind.Null, note.GetProperty("fifteenMinutesAtFive").ValueKind);
+        Assert.Equal(JsonValueKind.Null, note.GetProperty("fiveMinutesAtOne").ValueKind);
+        Assert.Equal("Data here is collected every hour.", note.GetProperty("thirtyMinutesAtHour").GetString());
+        Assert.Equal(JsonValueKind.Null, note.GetProperty("threeHoursAtHour").ValueKind);
+        Assert.Equal(JsonValueKind.Null, note.GetProperty("noInterval").ValueKind);
+
+        // R5: only a rolling, whole-hour length of an hour or more; a daily read wants whole days of a day or more.
+        var rolling = r.GetProperty("rolling");
+        Assert.Equal(JsonValueKind.Null, rolling.GetProperty("ok").ValueKind);
+        Assert.Equal("This page reads at least 1h back from now.", rolling.GetProperty("underAnHour").GetString());
+        Assert.Equal("This page reads whole hours back from now, such as 6h or 3d.", rolling.GetProperty("fractionalHours").GetString());
+        foreach (var name in new[] { "calendar", "finished", "since" })
+            Assert.Equal("This page reads a length back from now, so pick a rolling length such as 24h or 7d.", rolling.GetProperty(name).GetString());
+        Assert.Equal(JsonValueKind.Null, rolling.GetProperty("daysOk").ValueKind);
+        Assert.Equal("This page reads whole days back from now, such as 7d or 30d.", rolling.GetProperty("daysHours").GetString());
+        Assert.Equal("This page reads at least 1d back from now.", rolling.GetProperty("daysBelowFloor").GetString());
+
+        // A held range gives the read whole hours (rounded up) and, when finished, its end.
+        var window = r.GetProperty("window");
+        Assert.Equal(1, window.GetProperty("thirtyMinutes").GetProperty("hours").GetInt32());
+        Assert.Equal(JsonValueKind.Null, window.GetProperty("rolling").GetProperty("asOf").ValueKind);
+        Assert.Equal(24, window.GetProperty("finished").GetProperty("hours").GetInt32());
+        Assert.Equal("2026-10-08T10:00:00.000Z", window.GetProperty("finished").GetProperty("asOf").GetString());
+
+        // The sweep timeline and the job runs are cut at the range's start (newest first, so a row cap cannot hide a run in range).
+        Assert.Equal(3, r.GetProperty("sweeps").GetProperty("kept").GetInt32());
+        Assert.Equal(2, r.GetProperty("sweeps").GetProperty("all").GetInt32());
+        Assert.Equal(2, r.GetProperty("jobs").GetProperty("kept").GetInt32());
+    }
+}
diff --git a/Darling/Darling.Tests/alert-history-range-harness.mjs b/Darling/Darling.Tests/alert-history-range-harness.mjs
index e6de94caca..55bcee9832 100644
--- a/Darling/Darling.Tests/alert-history-range-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-range-harness.mjs
@@ -7,6 +7,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { pickRange, pickerText, pickerItems, popupShape, withDocumentListeners } from "./web-picker-driver.mjs";
 
 class FakeNode {
   constructor(tag) {
@@ -38,7 +39,7 @@ class FakeNode {
 }
 class FakeText extends FakeNode { constructor(t) { super("#text"); this._text = t; } }
 globalThis.Node = FakeNode;
-globalThis.document = { createElement: (t) => new FakeNode(t), createTextNode: (t) => new FakeText(t) };
+globalThis.document = withDocumentListeners({ createElement: (t) => new FakeNode(t), createTextNode: (t) => new FakeText(t) });
 globalThis.location = { hash: "#/alerts" };
 
 const jsDir = process.argv[2];
@@ -93,12 +94,17 @@ try {
       const main = newMain();
       await renderAlerts(main);
       out.first = readsOf().pop();
-      urls.length = 0; await pick(byLabel(main, "Time range"), 168); out.window = readsOf().pop();
+      urls.length = 0; pickRange(main, "Time range", "168h"); await settle(); out.window = readsOf().pop();
       urls.length = 0; await pick(byLabel(main, "Row limit"), 1000); out.limit = readsOf().pop();
       urls.length = 0; await pick(byLabel(main, "Server"), "srv-b"); out.server = readsOf().pop();
       const cb = checkbox(main);
       urls.length = 0; cb.checked = true; cb.fire("change"); await settle(); out.dismissed = readsOf().pop();
-      out.windowOptions = byLabel(main, "Time range").children.map((o) => o.attrs.value);
+      out.windowOptions = pickerItems(main, "Time range").filter((i) => !i.disabled).map((i) => i.name);
+      out.windowGreyed = pickerItems(main, "Time range").filter((i) => i.disabled).map((i) => i.name);
+      out.windowShape = popupShape(main, "Time range");
+      out.refused = pickRange(main, "Time range", "30d");
+      urls.length = 0; pickRange(main, "Time range", "yesterday"); await settle(); out.finished = readsOf().pop();
+      urls.length = 0; pickRange(main, "Time range", "30m"); await settle(); out.thirtyMinutes = readsOf().pop();
       out.limitOptions = byLabel(main, "Row limit").children.map((o) => o.attrs.value);
       out.serverOptions = byLabel(main, "Server").children.map((o) => o.attrs.value);
     },
@@ -106,7 +112,7 @@ try {
       alertsReply = { alerts: [row(1)], truncated: false };
       const first = newMain();
       await renderAlerts(first);
-      await pick(byLabel(first, "Time range"), 4);
+      pickRange(first, "Time range", "4h"); await settle();
       await pick(byLabel(first, "Row limit"), 500);
       await pick(byLabel(first, "Server"), "srv-a");
       const cb = checkbox(first); cb.checked = true; cb.fire("change"); await settle();
@@ -117,7 +123,7 @@ try {
       urls.length = 0; await renderAlerts(second);
       out.back = readsOf();
       out.shown = {
-        window: byLabel(second, "Time range").value, limit: byLabel(second, "Row limit").value,
+        window: pickerText(second, "Time range"), limit: byLabel(second, "Row limit").value,
         server: byLabel(second, "Server").value, dismissed: checkbox(second).checked,
       };
     },
@@ -169,11 +175,11 @@ try {
       out.before = metrics(main);
       // a narrower window: the oldest row leaves, a newer one lands first, one lands in the middle
       alertsReply = { alerts: [row(0), row(1), row(2), row(3)], truncated: false };
-      await pick(byLabel(main, "Time range"), 4);
+      pickRange(main, "Time range", "4h"); await settle();
       out.after = metrics(main);
       out.keptNode = bodyRows(main)[1] === keep;
       alertsReply = { alerts: [row(3)], truncated: false };
-      await pick(byLabel(main, "Time range"), 1);
+      pickRange(main, "Time range", "1h"); await settle();
       out.shrunk = metrics(main);
     },
     async mute() {
diff --git a/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs b/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
index 4734edb628..81cf475b5b 100644
--- a/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
+++ b/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
@@ -6,6 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { pickRange, pickerText, pickerItems, pickerButton, withDocumentListeners } from "./web-picker-driver.mjs";
 
 const jsDir = process.argv[2];
 
@@ -53,11 +54,11 @@ class FakeNode {
 }
 
 globalThis.Node = FakeNode;
-globalThis.document = {
+globalThis.document = withDocumentListeners({
   createElement: (tag) => new FakeNode(tag),
   createElementNS: (ns, tag) => new FakeNode(tag),
   createTextNode: (text) => new FakeNode("#text", text),
-};
+});
 
 const fetches = [];
 let body = "{}";
@@ -91,7 +92,7 @@ try {
   const settle = () => new Promise((r) => setTimeout(r, 20));
   const dbBody = { databases: { status: "ok", database_count: 1, truncated: false, rows: [{ database_name: "Alpha", current_size_mb: 10 }] } };
   const objBody = (days) => ({ database: { status: "ok" }, objects: { status: "ok", window_days: days, object_count: 0, truncated: false, days: [], rows: [] } });
-  const seen = () => fetches.map(paramsOf).map((p) => ({ view: p.view, hours: p.hours, database_name: p.database_name ?? null, limit: p.limit ?? null }));
+  const seen = () => fetches.filter((u) => String(u).includes("get_finops")).map(paramsOf).map((p) => ({ view: p.view, hours: p.hours, database_name: p.database_name ?? null, limit: p.limit ?? null }));
   const out = {};
 
   // The databases level: no window picker, 24 hours.
@@ -99,45 +100,49 @@ try {
   fetches.length = 0;
   let root = tab.build("srv-a", {});
   await settle();
-  out.databases = { reads: seen(), selects: findAll(root, "select").length };
+  out.databases = { reads: seen(), selects: pickerButton(root, "Window") ? 1 : 0 };
 
   // Open the database: the objects read at the default window (30 days = 720 hours), with the picker.
   body = JSON.stringify(objBody(30));
   fetches.length = 0;
   findText(root, "button", "Show objects").handlers.click();
   await settle();
-  let select = findAll(root, "select")[0];
-  out.objects = { reads: seen(), options: select.children.map((o) => o.attrs.value), value: select.value };
+  // #5562 R5: the Compact rolling-only picker, whole days (the heatmap has one column per day), reach 2160 hours for this view.
+  out.objects = {
+    reads: seen(),
+    options: pickerItems(root, "Window").filter((i) => !i.disabled).map((i) => i.name),
+    disabled: pickerItems(root, "Window").filter((i) => i.disabled).map((i) => i.name + ": " + i.why),
+    value: pickerText(root, "Window"),
+    refused: { hours: pickRange(root, "Window", "36h"), calendar: pickRange(root, "Window", "last month"), tooLong: pickRange(root, "Window", "120d") },
+  };
 
   // Pick 90 days, then 7 days: each re-reads with days * 24.
   for (const days of [90, 7]) {
     fetches.length = 0;
     body = JSON.stringify(objBody(days));
-    select = findAll(root, "select")[0];
-    select.value = String(days);
-    select.handlers.change();
+    pickRange(root, "Window", days + "d");
     await settle();
-    out["picked" + days] = { reads: seen(), value: findAll(root, "select")[0].value };
+    out["picked" + days] = { reads: seen(), value: pickerText(root, "Window") };
   }
 
   // The poll rebuilds the tab for the same server: one read with the picked window, picker still on it.
   fetches.length = 0;
   root = tab.build("srv-a", {});
   await settle();
-  out.rebuilt = { reads: seen(), value: findAll(root, "select")[0].value };
+  out.rebuilt = { reads: seen(), value: pickerText(root, "Window") };
 
   // Another server starts at the databases level.
   body = JSON.stringify(dbBody);
   fetches.length = 0;
   root = tab.build("srv-b", {});
   await settle();
-  out.other = { reads: seen(), selects: findAll(root, "select").length };
+  out.other = { reads: seen(), selects: pickerButton(root, "Window") ? 1 : 0 };
   // ... and its own objects read starts at 30 days.
   body = JSON.stringify(objBody(30));
   fetches.length = 0;
   findText(root, "button", "Show objects").handlers.click();
   await settle();
-  out.otherObjects = { reads: seen(), value: findAll(root, "select")[0].value };
+  out.otherObjects = { reads: seen(), value: pickerText(root, "Window") };
   console.log(JSON.stringify(out));
 } finally {
   fs.rmSync(scratch, { recursive: true, force: true });
diff --git a/Darling/Darling.Tests/finops-window-picker-harness.mjs b/Darling/Darling.Tests/finops-window-picker-harness.mjs
index 661efc4faa..ae2381ea74 100644
--- a/Darling/Darling.Tests/finops-window-picker-harness.mjs
+++ b/Darling/Darling.Tests/finops-window-picker-harness.mjs
@@ -6,6 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { pickRange, pickerText, pickerItems, popupShape, withDocumentListeners } from "./web-picker-driver.mjs";
 
 const jsDir = process.argv[2];
 
@@ -53,11 +54,11 @@ class FakeNode {
 }
 
 globalThis.Node = FakeNode;
-globalThis.document = {
+globalThis.document = withDocumentListeners({
   createElement: (tag) => new FakeNode(tag),
   createElementNS: (ns, tag) => new FakeNode(tag),
   createTextNode: (text) => new FakeNode("#text", text),
-};
+});
 
 const fetches = [];
 let body = "{}";
@@ -88,13 +89,18 @@ try {
     const run = async (server, pick) => {
       fetches.length = 0;
       const root = tab.build(server, {});
-      const select = find(root, "select");
-      if (pick != null) {
-        select.value = String(pick);
-        select.handlers.change();
-      }
+      if (pick != null) pickRange(root, "Window", pick + "h");
       await new Promise((r) => setTimeout(r, 20));
-      return { select: select.value, hours: fetches.map(hoursOf), options: select.children.map((o) => o.attrs.value) };
+      /* The catalog read the picker makes is not a FinOps read; only get_finops reads count. */
+      const reads = fetches.filter((u) => u.includes("get_finops"));
+      return {
+        select: pickerText(root, "Window"),
+        hours: reads.map(hoursOf),
+        options: pickerItems(root, "Window").filter((i) => !i.disabled).map((i) => i.name),
+        disabled: pickerItems(root, "Window").filter((i) => i.disabled).map((i) => i.name + ": " + i.why),
+        shape: popupShape(root, "Window"),
+        refused: { subHour: pickRange(root, "Window", "30m"), calendar: pickRange(root, "Window", "yesterday"), fractional: pickRange(root, "Window", "90m"), tooLong: pickRange(root, "Window", "30d") },
+      };
     };
     out[name] = {
       first: await run("srv-a"),
diff --git a/Darling/Darling.Tests/job-history-harness.mjs b/Darling/Darling.Tests/job-history-harness.mjs
index 438f0f45b5..865fa87d3b 100644
--- a/Darling/Darling.Tests/job-history-harness.mjs
+++ b/Darling/Darling.Tests/job-history-harness.mjs
@@ -6,6 +6,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { pickRange, pickerText, pickerItems, popupShape, withDocumentListeners } from "./web-picker-driver.mjs";
 
 const jsDir = process.argv[2];
 
@@ -88,11 +89,11 @@ class FakeNode {
 }
 
 globalThis.Node = FakeNode;
-globalThis.document = {
+globalThis.document = withDocumentListeners({
   createElement: (tag) => new FakeNode(tag),
   createElementNS: (ns, tag) => new FakeNode(tag),
   createTextNode: (text) => new FakeNode("#text", text),
-};
+});
 
 const fetches = [];
 let historyBody = "{}";
@@ -129,8 +130,8 @@ try {
 
   const run = {
     runs: [
-      { run_time: "2026-03-01T10:00:00Z", server: "srv-a", job_name: "Nightly", category: "Maintenance", step: "(Job outcome)", status: "Failed", duration_seconds: 5, duration_formatted: "00:00:05", retries: 0, last_success: null, message: "<b>boom</b>" },
-      { run_time: "2026-03-01T09:00:00Z", server: "srv-b", job_name: "Backup", category: "Backup", step: "1: Full", status: "Succeeded", duration_seconds: 9, duration_formatted: "00:00:09", retries: 0, last_success: null, message: "" },
+      { run_time: new Date(Date.now() - 10 * 60000).toISOString(), server: "srv-a", job_name: "Nightly", category: "Maintenance", step: "(Job outcome)", status: "Failed", duration_seconds: 5, duration_formatted: "00:00:05", retries: 0, last_success: null, message: "<b>boom</b>" },
+      { run_time: new Date(Date.now() - 20 * 60000).toISOString(), server: "srv-b", job_name: "Backup", category: "Backup", step: "1: Full", status: "Succeeded", duration_seconds: 9, duration_formatted: "00:00:09", retries: 0, last_success: null, message: "" },
     ],
     shown: 2, truncated: false, window_truncated: false,
   };
@@ -141,7 +142,8 @@ try {
   const out = {};
   const snapshot = (root) => ({
     calls: historyCalls(),
-    selects: Object.fromEntries(["Server", "Window", "Status", "Category", "Rows"].map((l) => [l, byLabel(root, l).value])),
+    selects: Object.fromEntries(["Server", "Status", "Category", "Rows"].map((l) => [l, byLabel(root, l).value])),
+    window: pickerText(root, "Window"),
     job: byLabel(root, "Job name").value,
     jobFocused: byLabel(root, "Job name").focused,
     categories: byLabel(root, "Category").children.map((o) => o.attrs.value),
@@ -168,6 +170,33 @@ try {
   await settle();
   out.picked = snapshot(main);
 
+  // The shared time range picker (#5562): a rolling length reads whole hours back, a finished range also sends its end as as_of
+  // (the reader bounds the runs by it before the row limit), a length past the reach is refused with the reason, and a sub-hour
+  // length is read as the whole hour and trimmed at its start.
+  fetches.length = 0;
+  out.range = {};
+  out.range.past30d = pickRange(main, "Window", "30d");
+  await settle();
+  out.range.past30dCalls = historyCalls().length;
+  fetches.length = 0;
+  pickRange(main, "Window", "2h");
+  await settle();
+  out.range.twoHours = { calls: historyCalls().map((c) => c.q), text: pickerText(main, "Window") };
+  fetches.length = 0;
+  pickRange(main, "Window", "yesterday");
+  await settle();
+  out.range.yesterday = { calls: historyCalls().map((c) => c.q), text: pickerText(main, "Window") };
+  fetches.length = 0;
+  historyBody = JSON.stringify({ ...run, runs: [{ ...run.runs[0], run_time: new Date(Date.now() - 5 * 60000).toISOString() }, { ...run.runs[1], run_time: new Date(Date.now() - 50 * 60000).toISOString() }] });
+  pickRange(main, "Window", "30m");
+  await settle();
+  out.range.thirtyMinutes = { calls: historyCalls().map((c) => c.q), shown: all(main, "div").filter((d) => d.className === "muted").map((d) => d.textContent) };
+  historyBody = JSON.stringify(run);
+  out.range.items = pickerItems(main, "Window").filter((i) => i.disabled).map((i) => i.name);
+  out.range.shape = popupShape(main, "Window");
+  pickRange(main, "Window", "1d");
+  await settle();
+
   // The poll rebuilds the page: the same choices, the typed text and the focus come back.
   fetches.length = 0;
   const again = new FakeNode("div");
diff --git a/Darling/Darling.Tests/page-range-harness.mjs b/Darling/Darling.Tests/page-range-harness.mjs
new file mode 100644
index 0000000000..8d6eff562c
--- /dev/null
+++ b/Darling/Darling.Tests/page-range-harness.mjs
@@ -0,0 +1,86 @@
+/* Runs the pure parts of the single-read pages' time range code (#5562, lane L2b) under Node and prints one line of JSON:
+   the collector interval a catalog serves for a collector (a per-server schedule row wins), the "collected every N minutes" note
+   (shown below 3 samples, never widening the range), the rolling-only refusals (R5), the whole-hours window a held range gives a
+   read, and the Fleet Sweep timeline's trim to the exact range.
+       node page-range-harness.mjs <path to wwwroot/js>
+   The whole js tree is copied into a scratch folder beside a package.json that marks it as an ES module (#5279). */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+const jsDir = process.argv[2];
+globalThis.document = { createElement: () => ({}), createTextNode: () => ({}) };
+
+const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "page-range-"));
+try {
+  fs.cpSync(jsDir, scratch, { recursive: true });
+  fs.writeFileSync(path.join(scratch, "package.json"), '{ "type": "module" }');
+  const load = (...parts) => import(pathToFileURL(path.join(scratch, ...parts)).href);
+  const pageRange = await load("page-range.js");
+  const tr = await load("time-range.js");
+
+  const MIN = 60000;
+  const HOUR = 3600000;
+  const catalog = (interval) => ({
+    reads: [
+      { name: "get_wait_trend", params: [{ name: "hours", collector: "wait_stats", collector_interval_minutes: interval, max_hours: 168 }] },
+      { name: "get_cpu_utilization", params: [{ name: "hours", collector: "cpu_utilization", collector_interval_minutes: 1, max_hours: 168 }] },
+      { name: "get_alert_history", params: [{ name: "hours", collector: null, collector_interval_minutes: null, max_hours: 168 }] },
+    ],
+  });
+  const out = {};
+
+  out.interval = {
+    waitStatsDefault: pageRange.collectorIntervalFromCatalog(catalog(1), "wait_stats") / MIN,
+    waitStatsServerOverride: pageRange.collectorIntervalFromCatalog(catalog(5), "wait_stats") / MIN,
+    unknownCollector: pageRange.collectorIntervalFromCatalog(catalog(1), "no_such"),
+    noCollector: pageRange.collectorIntervalFromCatalog(catalog(1), null),
+    noCatalog: pageRange.collectorIntervalFromCatalog(null, "wait_stats"),
+  };
+
+  const note = (spanMin, intervalMin) => tr.sampleIntervalNote(spanMin * MIN, intervalMin * MIN);
+  out.note = {
+    fiveMinutesAtFive: note(5, 5),
+    fourteenMinutesAtFive: note(14, 5),
+    fifteenMinutesAtFive: note(15, 5),
+    fiveMinutesAtOne: note(5, 1),
+    thirtyMinutesAtHour: note(30, 60),
+    threeHoursAtHour: note(180, 60),
+    noInterval: tr.sampleIntervalNote(5 * MIN, null),
+  };
+
+  const rolling = (spec, spanMs, minSpanMs, stepMs) => tr.rollingOnlyRefusal(spec, spanMs, minSpanMs, stepMs);
+  out.rolling = {
+    ok: rolling(tr.relativeSpec(24 * HOUR), 24 * HOUR),
+    underAnHour: rolling(tr.relativeSpec(30 * MIN), 30 * MIN),
+    fractionalHours: rolling(tr.relativeSpec(90 * MIN), 90 * MIN),
+    calendar: rolling(tr.calendarSpec("yesterday"), 24 * HOUR),
+    finished: rolling(tr.fixedSpec(0, 2 * HOUR), 2 * HOUR),
+    since: rolling(tr.sinceSpec(0), 2 * HOUR),
+    daysOk: rolling(tr.relativeSpec(30 * 24 * HOUR), 30 * 24 * HOUR, 24 * HOUR, 24 * HOUR),
+    daysHours: rolling(tr.relativeSpec(36 * HOUR), 36 * HOUR, 24 * HOUR, 24 * HOUR),
+    daysBelowFloor: rolling(tr.relativeSpec(12 * HOUR), 12 * HOUR, 24 * HOUR, 24 * HOUR),
+  };
+
+  const now = Date.parse("2026-10-08T12:00:00Z");
+  const w = (spec) => pageRange.windowOfSpec(spec, now, "UTC");
+  out.window = {
+    thirtyMinutes: w(tr.relativeSpec(30 * MIN)),
+    rolling: w(tr.relativeSpec(4 * HOUR)),
+    finished: w(tr.fixedSpec(now - 26 * HOUR, now - 2 * HOUR)),
+  };
+
+  const sweeps = await load("pages", "sweeps.js");
+  const stamp = (minutesAgo) => ({ swept_at: new Date(now - minutesAgo * MIN).toISOString() });
+  const trimmed = sweeps.timelineSweeps([stamp(5), stamp(20), stamp(50), { swept_at: "not a time" }], pageRange.windowOfSpec(tr.relativeSpec(30 * MIN), now, "UTC"));
+  out.sweeps = { kept: trimmed.length, all: sweeps.timelineSweeps([stamp(5), stamp(500)], null).length };
+
+  const jobs = await load("pages", "job-history.js");
+  const runs = [{ run_time: new Date(now - 5 * MIN).toISOString() }, { run_time: new Date(now - 50 * MIN).toISOString() }, { run_time: "?" }];
+  out.jobs = { kept: jobs.trimRunsToStart({ runs }, pageRange.windowOfSpec(tr.relativeSpec(30 * MIN), now, "UTC")).runs.length };
+
+  console.log(JSON.stringify(out));
+} finally {
+  fs.rmSync(scratch, { recursive: true, force: true });
+}
diff --git a/Darling/Darling.Tests/web-picker-driver.mjs b/Darling/Darling.Tests/web-picker-driver.mjs
new file mode 100644
index 0000000000..3d17c68ad3
--- /dev/null
+++ b/Darling/Darling.Tests/web-picker-driver.mjs
@@ -0,0 +1,78 @@
+/* Drives the shared time range picker (wwwroot/js/time-range-picker.js) inside the page harnesses' node-tree DOM (#5562).
+   A harness's FakeNode keeps one handler per event type and sets `className` through el(). The helpers here open the popup, type
+   a range into its text box and press Enter, exactly as a reader does, so a page test exercises the real control and not a
+   stand-in. Import it from a harness; it does not copy the js tree and reads no page file itself. */
+
+/** Raises an event on a harness node, whichever FakeNode shape it is (`handlers[type]` or `listeners[type]` with `fire`). */
+export function raise(node, type, event = {}) {
+  if (node.handlers && node.handlers[type]) return node.handlers[type](event);
+  if (typeof node.fire === "function") return node.fire(type, event);
+  throw new Error("no " + type + " handler on " + node.tag);
+}
+
+export function allNodes(node, out = []) {
+  out.push(node);
+  for (const c of node.children || []) allNodes(c, out);
+  return out;
+}
+
+/** The picker's button, found by the accessible name the page gave it ("Window", "Time range", ...). */
+export function pickerButton(root, label) {
+  return allNodes(root).find(
+    (n) => n.tag === "button" && String(n.className || "").includes("trp-button") && String(n.attrs["aria-label"] || "").startsWith(label + ":")
+  );
+}
+
+/** The button's text: the range name the picker shows ("Past 1 day", "Custom (45m)"). */
+export function pickerText(root, label) {
+  const b = pickerButton(root, label);
+  return b ? b.textContent : null;
+}
+
+/** The popup's items by their name, with whether each is greyed out and the reason it gives. Opens the popup. */
+export function pickerItems(root, label) {
+  const b = pickerButton(root, label);
+  raise(b, "click");
+  const items = allNodes(root)
+    .filter((n) => n.tag === "button" && String(n.className || "").includes("trp-item"))
+    .map((n) => ({
+      name: n.children[0].textContent,
+      disabled: String(n.className).includes("trp-disabled"),
+      why: (n.children.find((c) => String(c.className || "").includes("trp-item-why")) || { textContent: null }).textContent,
+    }));
+  raise(b, "click");
+  return items;
+}
+
+/** Whether the popup carries the calendar periods and the start-and-end boxes. */
+export function popupShape(root, label) {
+  const b = pickerButton(root, label);
+  raise(b, "click");
+  const nodes = allNodes(root);
+  const headings = nodes.filter((n) => String(n.className || "").includes("trp-heading")).map((n) => n.textContent);
+  const boxes = nodes.filter((n) => n.tag === "input" && n.attrs.type === "datetime-local").length;
+  raise(b, "click");
+  return { headings, dateBoxes: boxes };
+}
+
+/** Types `text` into the popup's box and presses Enter. Returns the preview line the picker showed before Enter. */
+export function pickRange(root, label, text) {
+  const b = pickerButton(root, label);
+  raise(b, "click");
+  const box = allNodes(root).find((n) => n.tag === "input" && n.attrs["aria-label"] === "Type a time range");
+  box.value = text;
+  raise(box, "input");
+  const preview = allNodes(root).find((n) => String(n.className || "").includes("trp-preview"));
+  const shown = preview ? preview.textContent : "";
+  raise(box, "keydown", { key: "Enter", preventDefault() {} });
+  /* A refused range leaves the popup open; close it so the next pick starts from the closed state. */
+  if (b.attrs["aria-expanded"] === "true") raise(b, "click");
+  return shown;
+}
+
+/** The document stub every harness needs once the picker's popup opens (it listens for an outside click only while open). */
+export function withDocumentListeners(doc) {
+  doc.addEventListener = doc.addEventListener || (() => {});
+  doc.removeEventListener = doc.removeEventListener || (() => {});
+  return doc;
+}

From 814a50f00e3cba9e77ed2447c63cff28504d04e1 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:26:47 -0400
Subject: [PATCH 12/33] Web module load harness treats finops/window.js as a
 helper, not a tab (#5562)

---
 Darling/Darling.Tests/WebHarness/load-web-modules.mjs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Darling/Darling.Tests/WebHarness/load-web-modules.mjs b/Darling/Darling.Tests/WebHarness/load-web-modules.mjs
index ed52931e65..80d7f33310 100644
--- a/Darling/Darling.Tests/WebHarness/load-web-modules.mjs
+++ b/Darling/Darling.Tests/WebHarness/load-web-modules.mjs
@@ -65,7 +65,8 @@ for (const f of files) {
   }
   // database-box.js is the shared Database box the Index Analysis and Locking tabs import (#5231): a helper, not a tab;
   // gate.js is the shared helper for the tabs' empty and not-collected states on a PostgreSQL target, also not a tab.
-  if (name.startsWith("pages/finops/") && name !== "pages/finops/database-box.js" && name !== "pages/finops/gate.js") {
+  // window.js is the rolling-only time range picker the windowed tabs share (#5562), also not a tab.
+  if (name.startsWith("pages/finops/") && name !== "pages/finops/database-box.js" && name !== "pages/finops/gate.js" && name !== "pages/finops/window.js") {
     if (!m.tab || typeof m.tab.build !== "function" || !m.tab.id) {
       console.error(name + " does not export tab = { id, build }");
       process.exit(1);

From 164f7a71b2aeeaa7c224719bba53c12299cd04b3 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:27:24 -0400
Subject: [PATCH 13/33] The Viewer's FinOps pickers are rolling-only, Job
 History bounds a finished range in the SQL, every banner feeds the data-start
 note, Alert History's All is its retention (#5562)

---
 .../DarlingMcpJobHistoryToolTests.cs          |   2 +-
 ...roupedStatsMatchWindowFunctionLiveTests.cs |   4 +-
 .../JobHistoryPerServerTopNLiveTests.cs       |   8 +-
 .../ViewerJobHistoryDataStartLiveTests.cs     |   2 +-
 .../ViewerJobHistoryDataStartTests.cs         |   9 +-
 .../ViewerTimeRangeGapFixTests.cs             | 383 ++++++++++++++++++
 .../ViewerTypedRangeZoneTests.cs              |  13 +-
 .../AlertsHistoryTab.xaml                     |   2 +-
 .../AlertsHistoryTab.xaml.cs                  |   2 +
 .../FinOpsTab.Loaders.cs                      |   7 +-
 .../FinOpsTab.ObjectHeatmap.cs                |   5 +-
 .../FinOpsTab.xaml.cs                         |   6 +-
 .../JobHistoryTab.xaml.cs                     |  21 +-
 .../ViewerDataService.JobHistory.cs           |   9 +-
 .../ViewerDataStartNote.cs                    |  65 +++
 .../ViewerServerTab.ActiveQueries.cs          |   2 +-
 .../ViewerServerTab.Blocking.cs               |   2 +-
 .../ViewerServerTab.Postgres.cs               |   2 +-
 .../ViewerServerTab.Queries.cs                |  10 +-
 .../ViewerServerTab.TimeRange.cs              |  13 +-
 .../ViewerTimeRangeWindow.cs                  |   7 +
 .../TimeRange/RollingUnitRule.cs              |  53 +++
 PerformanceMonitor.Ui/TimeRangePicker.xaml    |   2 +-
 PerformanceMonitor.Ui/TimeRangePicker.xaml.cs | 102 ++++-
 24 files changed, 676 insertions(+), 55 deletions(-)
 create mode 100644 Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
 create mode 100644 Darling/PerformanceMonitor.Darling.Viewer/ViewerDataStartNote.cs
 create mode 100644 PerformanceMonitor.Ui/TimeRange/RollingUnitRule.cs

diff --git a/Darling/Darling.Tests/DarlingMcpJobHistoryToolTests.cs b/Darling/Darling.Tests/DarlingMcpJobHistoryToolTests.cs
index 6329b09b8e..a57612dc8a 100644
--- a/Darling/Darling.Tests/DarlingMcpJobHistoryToolTests.cs
+++ b/Darling/Darling.Tests/DarlingMcpJobHistoryToolTests.cs
@@ -299,7 +299,7 @@ public async Task ViewerRows_EqualTheStorageReaderRows_MappedThroughFrom()
             var since = AsOf.AddHours(-24);
 
             await using var viewer = new ViewerDataService(Cs!);
-            var viewerRows = await viewer.GetJobHistoryAsync(since, null, 2000, ct);
+            var viewerRows = await viewer.GetJobHistoryAsync(since, null, 2000, cancellationToken: ct);
             var storage = await DarlingJobHistoryReader.GetAsync(postgres, since, null, 2000, 60, cancellationToken: ct);
 
             /* D5: the viewer stamps each row with its own server's clock, which the storage reader's row does not carry, and
diff --git a/Darling/Darling.Tests/JobHistoryGroupedStatsMatchWindowFunctionLiveTests.cs b/Darling/Darling.Tests/JobHistoryGroupedStatsMatchWindowFunctionLiveTests.cs
index 64f91401c3..974e8a0497 100644
--- a/Darling/Darling.Tests/JobHistoryGroupedStatsMatchWindowFunctionLiveTests.cs
+++ b/Darling/Darling.Tests/JobHistoryGroupedStatsMatchWindowFunctionLiveTests.cs
@@ -170,7 +170,7 @@ await InsertJobHistoryAsync(connection, ct, id: 201, at: tied.AddSeconds(1), job
             const int limit = 5;
 
             var oldRows = await ReadOldAsync(connection, sinceUtc, ct, limit);
-            var newRows = await viewer.GetJobHistoryAsync(sinceUtc, ServerId, limit, ct);
+            var newRows = await viewer.GetJobHistoryAsync(sinceUtc, ServerId, limit, cancellationToken: ct);
 
             /* Same count, same rows, same order, same values — the join replaces the window function without
                changing what the tab shows. */
@@ -328,7 +328,7 @@ await InsertJobHistoryAsync(connection, ct, id: 301, at: at, jobId: "shared_job"
             /* Fleet-wide (no server filter) is the shape whose job_stats join actually needs the server_id
                half; a large limit plus a client-side filter to just these two rows keeps the shared
                darlingtest store's other rows from being the thing that decides the LIMIT boundary here. */
-            var rows = await viewer.GetJobHistoryAsync(sinceUtc, serverId: null, limit: 2000, ct);
+            var rows = await viewer.GetJobHistoryAsync(sinceUtc, serverId: null, limit: 2000, cancellationToken: ct);
             var mine = rows.Where(r => r.JobId == "shared_job" && (r.ServerId == ServerId || r.ServerId == ServerId2)).ToList();
 
             Assert.Equal(2, mine.Count);
diff --git a/Darling/Darling.Tests/JobHistoryPerServerTopNLiveTests.cs b/Darling/Darling.Tests/JobHistoryPerServerTopNLiveTests.cs
index 7e9235e20d..8879e84334 100644
--- a/Darling/Darling.Tests/JobHistoryPerServerTopNLiveTests.cs
+++ b/Darling/Darling.Tests/JobHistoryPerServerTopNLiveTests.cs
@@ -211,7 +211,7 @@ await InsertJobHistoryAsync(connection, ct, id: 1, at: at, jobId: "orphan_job",
                 serverName: "darling-4477-gone-raw");
             await DarlingMcpTestData.ExecAsync(connection, ct, "DELETE FROM servers WHERE server_id = $1", ServerDeregistered);
 
-            var rows = await viewer.GetJobHistoryAsync(sinceUtc, serverId: null, limit: 2000, ct);
+            var rows = await viewer.GetJobHistoryAsync(sinceUtc, serverId: null, limit: 2000, cancellationToken: ct);
             var orphan = rows.SingleOrDefault(r => r.JobId == "orphan_job" && r.ServerId == ServerDeregistered);
 
             Assert.NotNull(orphan);
@@ -220,7 +220,7 @@ like the old COALESCE(reg.display_name, jh.server_name) with reg NULL. */
             Assert.Equal("darling-4477-gone-raw", orphan!.ServerName);
 
             /* And it is reachable server-scoped too — the read's other parameter shape. */
-            var scoped = await viewer.GetJobHistoryAsync(sinceUtc, ServerDeregistered, 2000, ct);
+            var scoped = await viewer.GetJobHistoryAsync(sinceUtc, ServerDeregistered, 2000, cancellationToken: ct);
             Assert.Contains(scoped, r => r.JobId == "orphan_job");
 
             bodySucceeded = true;
@@ -327,7 +327,7 @@ so the boundary itself — not just "everything came back" — is under test. */
             const int limit = 20;
 
             var oldRows = await ReadOldFleetAsync(connection, sinceUtc, limit, ct);
-            var newRows = await viewer.GetJobHistoryAsync(sinceUtc, serverId: null, limit, ct);
+            var newRows = await viewer.GetJobHistoryAsync(sinceUtc, serverId: null, limit, cancellationToken: ct);
 
             Assert.Equal(limit, newRows.Count);
             Assert.Equal(oldRows.Count, newRows.Count);
@@ -339,7 +339,7 @@ so the boundary itself — not just "everything came back" — is under test. */
             /* And scoped-to-one-server, for the server with the same-server tie — the other parameter shape,
                same equivalence requirement. */
             var oldScopedRows = await ReadOldScopedFullAsync(connection, sinceUtc, ServerZeroOffset, limit, ct);
-            var newScopedRows = await viewer.GetJobHistoryAsync(sinceUtc, ServerZeroOffset, limit, ct);
+            var newScopedRows = await viewer.GetJobHistoryAsync(sinceUtc, ServerZeroOffset, limit, cancellationToken: ct);
             Assert.Equal(oldScopedRows.Count, newScopedRows.Count);
             for (var i = 0; i < oldScopedRows.Count; i++)
             {
diff --git a/Darling/Darling.Tests/ViewerJobHistoryDataStartLiveTests.cs b/Darling/Darling.Tests/ViewerJobHistoryDataStartLiveTests.cs
index 295a695e7f..8747fc62b6 100644
--- a/Darling/Darling.Tests/ViewerJobHistoryDataStartLiveTests.cs
+++ b/Darling/Darling.Tests/ViewerJobHistoryDataStartLiveTests.cs
@@ -194,7 +194,7 @@ public static async Task<Store> CreateAsync(CancellationToken ct)
         public async Task<string?> NoteAsync(int? serverId, CancellationToken ct)
         {
             var probe = Viewer.GetJobHistoryDataStartAsync(serverId, Start, End, ct);
-            var read = await Viewer.GetJobHistoryAsync(Start, serverId, JobHistoryTab.RowCap, ct);
+            var read = await Viewer.GetJobHistoryAsync(Start, serverId, JobHistoryTab.RowCap, cancellationToken: ct);
             await probe.WaitAsync(ct);
 
             string? text = null;
diff --git a/Darling/Darling.Tests/ViewerJobHistoryDataStartTests.cs b/Darling/Darling.Tests/ViewerJobHistoryDataStartTests.cs
index 6bd8b51faa..9c9381212a 100644
--- a/Darling/Darling.Tests/ViewerJobHistoryDataStartTests.cs
+++ b/Darling/Darling.Tests/ViewerJobHistoryDataStartTests.cs
@@ -117,11 +117,14 @@ public void TheTab_WorksOutTheWindowsStartOnce_AndHandsItToTheReadAndTheProbe()
     {
         var load = MethodBody(ViewerFile("JobHistoryTab.xaml.cs"), @"private async Task LoadJobsAsync\(");
 
-        Assert.Equal(1, Matches(load, @"var nowUtc = DateTime\.UtcNow;"));
-        Assert.Equal(1, Matches(load, @"var sinceUtc = nowUtc\.AddHours\(-hoursBack\);"));
+        /* #5562: the window comes from the picker once; its start and end are the ones the read and the probe take. */
+        Assert.Equal(1, Matches(load, @"var nowUtc = windowEndUtc;"));
+        Assert.Equal(1, Matches(load, @"var sinceUtc = windowStartUtc;"));
+        Assert.Equal(1, Matches(load, @"ViewerTimeRangeWindow\.Window\("));
         Assert.Equal(0, Matches(load, @"DateTime\.UtcNow\.AddHours"));
         Assert.Equal(1, Matches(load, @"var dataStartTask = _dataService\.GetJobHistoryDataStartAsync\(serverId,\s*sinceUtc,\s*nowUtc\);"));
-        Assert.Equal(1, Matches(load, @"var readTask = _dataService\.GetJobHistoryAsync\(sinceUtc,\s*serverId,\s*RowCap\)"));
+        /* #5562 R6: a finished range hands its end to the read, so the end bound lands before the row cap. */
+        Assert.Equal(1, Matches(load, @"var readTask = _dataService\.GetJobHistoryAsync\(sinceUtc,\s*serverId,\s*RowCap,\s*untilUtc:\s*windowIsLive \? null : windowEndUtc\)"));
         /* The probe starts beside the read, not after it. */
         Assert.True(
             load.IndexOf("GetJobHistoryDataStartAsync(", StringComparison.Ordinal) < load.IndexOf("var readTask = _dataService.GetJobHistoryAsync(", StringComparison.Ordinal),
diff --git a/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs b/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
new file mode 100644
index 0000000000..9e3a1a50a5
--- /dev/null
+++ b/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
@@ -0,0 +1,383 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+using Npgsql;
+using PerformanceMonitor.Darling.Storage;
+using PerformanceMonitor.Darling.Viewer;
+using PerformanceMonitor.Ui;
+using Xunit;
+
+/* Darling.Tests only: a Darling file Lite.Tests compiles must be named in build.yml's Lite path filter. */
+namespace Darling.Tests;
+
+/// <summary>
+/// #5562, the four gaps the first Viewer pass left. R5: a FinOps picker offers only a range its "hours back from now" read can
+/// honor. R6: Job History's finished range is bounded in the SQL, before the row cap. R7: every "Showing since" banner site feeds
+/// the picker's data-start note. R8: Alert History's longest choice is the span its table keeps.
+/// </summary>
+[Collection("live-postgres")]
+public sealed class ViewerTimeRangeGapFixTests
+{
+    private static string ViewerFile(string file) => RepoFile.ReadRepoFile("Darling", "PerformanceMonitor.Darling.Viewer", file);
+
+    private static string Code(string file) => ViewerTypedRangeTests.StripComments(ViewerFile(file));
+
+    private static TimeRangeSpec Spec(string id)
+    {
+        Assert.True(TimeRangeSpec.TryFromId(id, out var spec), id);
+        return spec!;
+    }
+
+    // ── R5: FinOps pickers are rolling-only, in whole hours (the heatmap in whole days) ──
+
+    [Theory]
+    [InlineData("1h", true)]
+    [InlineData("4h", true)]
+    [InlineData("1d", true)]
+    [InlineData("1w", true)]
+    [InlineData("1mo", true)]
+    [InlineData("90m", false)]
+    [InlineData("30m", false)]
+    [InlineData("5m", false)]
+    [InlineData("today", false)]
+    [InlineData("previous-week", false)]
+    [InlineData("since:2026-10-01T04:00:00Z", false)]
+    [InlineData("fixed:2026-10-01T04:00:00Z/2026-10-02T04:00:00Z", false)]
+    public void TheHourRule_AdmitsOnlyAWholeNumberOfHoursBackFromNow(string id, bool admitted)
+    {
+        var spec = id == "90m" ? TimeRangeSpec.Relative(TimeSpan.FromMinutes(90)) : Spec(id);
+        Assert.Equal(admitted, RollingUnitRule.Admits(spec, RollingUnitRule.Hour));
+        Assert.Equal(admitted, RollingUnitRule.Refusal(spec, RollingUnitRule.Hour) is null);
+    }
+
+    [Theory]
+    [InlineData("1d", true)]
+    [InlineData("2d", true)]
+    [InlineData("1mo", true)]
+    [InlineData("1h", false)]
+    [InlineData("4h", false)]
+    public void TheDayRule_AdmitsOnlyAWholeNumberOfDaysBackFromNow(string id, bool admitted)
+    {
+        var spec = Spec(id);
+        Assert.Equal(admitted, RollingUnitRule.Admits(spec, RollingUnitRule.Day));
+        Assert.False(RollingUnitRule.Admits(TimeRangeSpec.Relative(TimeSpan.FromHours(36)), RollingUnitRule.Day));
+        Assert.False(RollingUnitRule.Admits(TimeRangeSpec.ForPeriod(CalendarPeriod.MonthToDate), RollingUnitRule.Day));
+    }
+
+    [Fact]
+    public void TheRefusal_SaysWhatTheReadTakes()
+    {
+        Assert.Equal("The shortest range for this read is 1 hour.", RollingUnitRule.Refusal(TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)), RollingUnitRule.Hour));
+        Assert.Equal("This read takes whole hours; try 2h.", RollingUnitRule.Refusal(TimeRangeSpec.Relative(TimeSpan.FromMinutes(90)), RollingUnitRule.Hour));
+        Assert.Contains("length back from now", RollingUnitRule.Refusal(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), RollingUnitRule.Hour), StringComparison.Ordinal);
+        Assert.Equal("The shortest range for this read is 1 day.", RollingUnitRule.Refusal(TimeRangeSpec.Relative(TimeSpan.FromHours(4)), RollingUnitRule.Day));
+    }
+
+    [Fact]
+    public void ARollingOnlyPicker_RefusesWhatItsReadCannotHonor_AndHidesTheCalendar()
+    {
+        OnStaThread(() =>
+        {
+            var now = new DateTime(2026, 10, 8, 11, 1, 0, DateTimeKind.Unspecified);
+            var picker = new TimeRangePicker { ZoneProvider = () => TimeZoneInfo.Utc, NowProvider = () => now, Compact = true };
+            picker.RollingUnit = RollingUnitRule.Hour;
+            var raised = 0;
+            picker.RangeChanged += (_, _) => raised++;
+
+            Assert.Equal(System.Windows.Visibility.Collapsed, picker.PeriodPanel.Visibility);
+            Assert.Equal(System.Windows.Visibility.Collapsed, picker.PickCalendar.Visibility);
+            Assert.Equal(System.Windows.Visibility.Collapsed, picker.CalendarHeader.Visibility);
+
+            /* Presets under an hour are greyed; the others stay. */
+            var enabled = picker.RollingPanel.Children.OfType<Button>().Where(b => b.IsEnabled).Select(b => ((TimeRangeSpec)b.Tag).Id).ToArray();
+            Assert.Equal(new[] { "1h", "4h", "1d", "2d", "1w", "1mo" }, enabled);
+
+            Assert.False(picker.Select(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek)));
+            Assert.False(picker.Select(TimeRangeSpec.FixedRange(now.AddDays(-2), now.AddDays(-1))));
+            Assert.False(picker.Select(TimeRangeSpec.SinceInstant(now.AddDays(-2))));
+            Assert.False(picker.Select(TimeRangeSpec.Relative(TimeSpan.FromMinutes(45))));
+            Assert.Equal(0, raised);
+            Assert.Equal("4h", picker.Value.Id);
+
+            Assert.True(picker.Select(TimeRangeSpec.Relative(TimeSpan.FromHours(6))));
+            Assert.Equal(1, raised);
+
+            /* Typed text goes through the same rule: a calendar period and a part hour are refused with the reason. */
+            picker.InputBox.Text = "last month";
+            Assert.False(picker.ApplyButton.IsEnabled);
+            Assert.Contains("length back from now", picker.EchoText.Text, StringComparison.Ordinal);
+            picker.InputBox.Text = "90m";
+            Assert.False(picker.ApplyButton.IsEnabled);
+            Assert.Equal("This read takes whole hours; try 2h.", picker.EchoText.Text);
+            picker.InputBox.Text = "3 days";
+            Assert.True(picker.ApplyButton.IsEnabled);
+
+            /* A plain picker is unchanged. */
+            picker.RollingUnit = null;
+            Assert.Equal(System.Windows.Visibility.Visible, picker.PeriodPanel.Visibility);
+            Assert.True(picker.Select(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek)));
+        });
+    }
+
+    [Fact]
+    public void EveryFinOpsPicker_IsCompactAndRollingOnly_TheListsInHoursAndTheHeatmapInDays()
+    {
+        var xaml = ViewerFile("FinOpsTab.xaml");
+        var pickers = Regex.Matches(xaml, @"<ui:TimeRangePicker x:Name=""(?<name>\w+)""[^>]*>");
+        Assert.Equal(5, pickers.Count);
+        foreach (Match picker in pickers)
+        {
+            Assert.Contains("Compact=\"True\"", picker.Value, StringComparison.Ordinal);
+        }
+
+        var code = Code("FinOpsTab.xaml.cs");
+        /* The four lists share one loop: one assignment, in whole hours; the heatmap sets its own, in whole days. */
+        Assert.Single(Regex.Matches(code, @"picker\.RollingUnit = RollingUnitRule\.Hour;"));
+        Assert.Single(Regex.Matches(code, @"FinOpsObjectHeatmapWindowCombo\.RollingUnit = RollingUnitRule\.Day;"));
+        foreach (var name in new[] { "FinOpsResourceUsageTimeRangeCombo", "FinOpsWaitStatsTimeRangeCombo", "FinOpsExpensiveQueriesTimeRangeCombo", "FinOpsHighImpactTimeRangeCombo" })
+        {
+            Assert.Contains(name, code, StringComparison.Ordinal);
+        }
+
+        /* Nothing else sets the five pickers' Value to a range the rule refuses. */
+        foreach (Match assignment in Regex.Matches(code, @"\.Value = TimeRangePresets\.Find\(""(?<id>\w+)""\)"))
+        {
+            Assert.True(RollingUnitRule.Admits(TimeRangePresets.Find(assignment.Groups["id"].Value)!, RollingUnitRule.Hour), assignment.Value);
+        }
+    }
+
+    // ── R7: every banner site feeds the picker's data-start note ──
+
+    [Fact]
+    public void TheBannerSites_AreCountedAndEveryOneFeedsThePickersNote()
+    {
+        var updateSites = 0;
+        var eventSites = 0;
+        var viewerDir = RepoFile.PathTo("Darling", "PerformanceMonitor.Darling.Viewer");
+        foreach (var file in Directory.EnumerateFiles(viewerDir, "*.cs"))
+        {
+            var code = ViewerTypedRangeTests.StripComments(File.ReadAllText(file));
+            updateSites += Regex.Matches(code, @"\bUpdateTruncationBanner\(").Count - Regex.Matches(code, @"void UpdateTruncationBanner\(").Count;
+            eventSites += Regex.Matches(code, @"\bShowEventDataStartAsync\(").Count - Regex.Matches(code, @"Task ShowEventDataStartAsync\(").Count;
+        }
+
+        /* A new banner site changes these counts: it must go through UpdateTruncationBanner (the event surfaces through
+           ShowEventDataStartAsync, which ends in it), which feeds the note below. Raise the count with the site. */
+        Assert.Equal(35, updateSites);
+        Assert.Equal(29, eventSites);
+
+        var update = ViewerTypedRangeTests.StripComments(ViewerTypedRangeTests.MemberText(ViewerFile("ViewerServerTab.Queries.cs"), "UpdateTruncationBanner"));
+        Assert.Matches(@"\{\s*ViewerDataStartNote\.Feed\(banner, floor\);", update);
+
+        var show = ViewerTypedRangeTests.StripComments(ViewerTypedRangeTests.MemberText(ViewerFile("ViewerServerTab.EventDataStart.cs"), "ShowEventDataStartAsync"));
+        Assert.Single(Regex.Matches(show, @"\bUpdateTruncationBanner\("));
+
+        /* The feed reaches the two tabs that own a picker and a banner, and sets the note from the floor with no query. */
+        var note = ViewerTypedRangeTests.StripComments(ViewerFile("ViewerDataStartNote.cs"));
+        Assert.Contains("serverTab.RecordDataStart(floor)", note, StringComparison.Ordinal);
+        Assert.Contains("jobHistory.RecordDataStart(floor)", note, StringComparison.Ordinal);
+        Assert.DoesNotContain("await", note, StringComparison.Ordinal);
+        Assert.Contains("TimeRangePickerControl.DataStartUtc = floor", Code("JobHistoryTab.xaml.cs"), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void TheFeed_ReachesOnlyABannerThatIsOnScreenInATab()
+    {
+        OnStaThread(() =>
+        {
+            var banner = new TextBlock();
+            var host = new Border();
+            var outer = new StackPanel();
+            Assert.Null(ViewerDataStartNote.FindAncestor<StackPanel>(banner));
+
+            host.Child = banner;
+            outer.Children.Add(host);
+            Assert.Same(host, ViewerDataStartNote.FindAncestor<Border>(banner));
+            Assert.Same(outer, ViewerDataStartNote.FindAncestor<StackPanel>(banner));
+
+            /* A bare banner (a test's control, or a tab that is not on screen) feeds nothing and throws nothing. */
+            ViewerDataStartNote.Feed(new TextBlock(), new DateTime(2026, 10, 1, 0, 0, 0, DateTimeKind.Unspecified));
+            ViewerDataStartNote.Feed(banner, null);
+        });
+    }
+
+    // ── R8: Alert History's longest choice ──
+
+    [Fact]
+    public void AlertHistory_LongestChoice_IsTheSpanTheAlertTableKeeps()
+    {
+        /* The retention is DarlingRetentionHorizons.AlertHistoryRetentionDays (config_alert_log is purged past it, 90 days). The
+           choice is that span, capped at a year if the retention is ever raised. */
+        var days = Math.Min(DarlingRetentionHorizons.AlertHistoryRetentionDays, 365);
+        Assert.Equal(TimeSpan.FromDays(days), ViewerTimeRangeWindow.AlertHistoryLongestChoice.Span);
+        Assert.Equal(TimeRangeKind.Relative, ViewerTimeRangeWindow.AlertHistoryLongestChoice.Kind);
+        Assert.True(DarlingRetentionHorizons.AlertHistoryRetentionDays <= 365, "retention above a year: re-read #5562 R8");
+        Assert.Contains("SetLongestChoice(ViewerTimeRangeWindow.AlertHistoryLongestChoice", Code("AlertsHistoryTab.xaml.cs"), StringComparison.Ordinal);
+        Assert.DoesNotContain("365d\")", Code("AlertsHistoryTab.xaml.cs"), StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void ThePickersLongestChoice_IsOneMoreButton_ThatSelectsItsSpan()
+    {
+        OnStaThread(() =>
+        {
+            var now = new DateTime(2026, 10, 8, 11, 1, 0, DateTimeKind.Unspecified);
+            var picker = new TimeRangePicker { ZoneProvider = () => TimeZoneInfo.Utc, NowProvider = () => now, Compact = true };
+            Assert.Equal(9, picker.RollingPanel.Children.Count);
+
+            picker.SetLongestChoice(ViewerTimeRangeWindow.AlertHistoryLongestChoice, "All");
+            Assert.Equal(10, picker.RollingPanel.Children.Count);
+            var all = (Button)picker.RollingPanel.Children[9];
+            Assert.Equal("All", all.Content);
+            Assert.Equal("90d", ((TimeRangeSpec)all.Tag).Id);
+
+            TimeRangeChangedEventArgs? last = null;
+            picker.RangeChanged += (_, e) => last = e;
+            Assert.True(picker.Select((TimeRangeSpec)all.Tag));
+            Assert.Equal(TimeSpan.FromDays(90), last!.Range.Span);
+
+            picker.SetLongestChoice(null);
+            Assert.Equal(9, picker.RollingPanel.Children.Count);
+        });
+    }
+
+    // ── R6: Job History's end bound, applied before the row cap ──
+
+    [Fact]
+    public void TheJobHistoryTab_HandsAFinishedRangesEndToTheRead_AndNoLongerTrimsOnTheClient()
+    {
+        var tab = Code("JobHistoryTab.xaml.cs");
+        Assert.Matches(@"GetJobHistoryAsync\(sinceUtc,\s*serverId,\s*RowCap,\s*untilUtc:\s*windowIsLive \? null : windowEndUtc\)", tab);
+        Assert.DoesNotContain("windowEndUtc).ToList()", tab, StringComparison.Ordinal);
+        Assert.DoesNotContain("ran < windowEndUtc", tab, StringComparison.Ordinal);
+
+        var read = ViewerTypedRangeTests.StripComments(ViewerTypedRangeTests.MemberText(ViewerFile("ViewerDataService.JobHistory.cs"), "GetJobHistoryAsync"));
+        Assert.Contains("new JobHistoryFilter(UntilUtc: until.AddTicks(-TimeSpan.TicksPerMicrosecond))", read, StringComparison.Ordinal);
+    }
+
+    private const int EndBoundServer = -556_201;
+    private const long EndBoundIdBase = 5_562_000_000L;
+
+    [Fact]
+    public async Task AFinishedRange_KeepsEveryRunInsideIt_WhenMoreRunsAfterItsEndThanTheCap()
+    {
+        var connectionString = Environment.GetEnvironmentVariable("DARLING_TEST_PG");
+        Assert.SkipWhen(string.IsNullOrEmpty(connectionString),
+            "Set DARLING_TEST_PG to a Postgres connection string to run the #5562 job-history end-bound live test.");
+
+        var ct = TestContext.Current.CancellationToken;
+        using var connection = new NpgsqlConnection(connectionString);
+        await connection.OpenAsync(ct);
+        await PgMigrations.MigrateAsync(connection, ct);
+        await CleanupAsync(connection, ct);
+
+        await using var viewer = new ViewerDataService(connectionString!);
+        var bodySucceeded = false;
+        try
+        {
+            await DarlingMcpTestData.RegisterServerAsync(connection, EndBoundServer, "darling-5562-endbound", ct);
+
+            /* The range: two days ago to one day ago. The server has no server_properties row, so its clock is UTC. */
+            var end = DarlingMcpTestData.TruncateToSeconds(DateTime.UtcNow).AddDays(-1);
+            var start = end.AddDays(-1);
+            var id = 0L;
+            var inside = new System.Collections.Generic.List<(string Job, DateTime At)>();
+
+            for (var i = 1; i <= 6; i++)
+            {
+                var at = start.AddHours(i * 3);
+                await InsertAsync(connection, ct, ++id, at, "inside_" + i);
+                inside.Add(("inside_" + i, at));
+            }
+
+            /* The newest run before the end, with microseconds the store keeps, and the start itself. */
+            var lastInside = end.AddTicks(-10);
+            await InsertAsync(connection, ct, ++id, lastInside, "inside_last_microsecond");
+            inside.Add(("inside_last_microsecond", lastInside));
+            await InsertAsync(connection, ct, ++id, start, "inside_at_start");
+            inside.Add(("inside_at_start", start));
+
+            /* Outside: a run exactly at the end (the end is exclusive), one before the start, and 40 after the end, more than
+               the cap of 10 used below. */
+            await InsertAsync(connection, ct, ++id, end, "outside_at_end");
+            await InsertAsync(connection, ct, ++id, start.AddMinutes(-1), "outside_before_start");
+            for (var i = 1; i <= 40; i++)
+            {
+                await InsertAsync(connection, ct, ++id, end.AddMinutes(i * 10), "after_" + i);
+            }
+
+            const int cap = 10;
+
+            /* The start-only read (the old shape) fills its cap from the runs after the end: nothing of the range survives a client trim. */
+            var startOnly = await viewer.GetJobHistoryAsync(start, EndBoundServer, cap, cancellationToken: ct);
+            Assert.Equal(cap, startOnly.Count);
+            Assert.DoesNotContain(startOnly, r => r.RunDateTimeUtc is { } ran && ran < end);
+
+            /* With the end bound the SQL applies it before the cap: every run inside the range comes back, newest first. */
+            var bounded = await viewer.GetJobHistoryAsync(start, EndBoundServer, cap, untilUtc: end, cancellationToken: ct);
+            Assert.Equal(inside.Count, bounded.Count);
+            Assert.All(bounded, r => Assert.True(r.RunDateTimeUtc is { } ran && ran >= start && ran < end, r.JobName));
+            Assert.Equal(inside.OrderByDescending(r => r.At).Select(r => r.Job).ToArray(), bounded.Select(r => r.JobName).ToArray());
+            Assert.Equal(lastInside, bounded[0].RunDateTimeUtc);
+            Assert.DoesNotContain(bounded, r => r.JobName is "outside_at_end" or "outside_before_start");
+
+            /* A cap smaller than the range still cuts the newest of the range, not of everything since the start. */
+            var capped = await viewer.GetJobHistoryAsync(start, EndBoundServer, 3, untilUtc: end, cancellationToken: ct);
+            Assert.Equal(new[] { "inside_last_microsecond", "inside_6", "inside_5" }, capped.Select(r => r.JobName).ToArray());
+
+            bodySucceeded = true;
+        }
+        finally
+        {
+            await LiveStoreCleanup.RunAsync(connectionString!, bodySucceeded, CleanupAsync);
+        }
+    }
+
+    private static Task InsertAsync(NpgsqlConnection connection, CancellationToken ct, long id, DateTime at, string job) =>
+        DarlingMcpTestData.ExecAsync(connection, ct,
+            @"INSERT INTO job_history (job_history_id, collection_time, server_id, server_name, instance_id,
+                                       job_id, job_name, job_enabled, step_id, step_name, run_status,
+                                       run_status_desc, run_datetime, run_duration_seconds, retries_attempted, message)
+              VALUES ($1,$2,$3,$4,$5,$6,$7,true,0,'(Job outcome)',1,'The job succeeded.',$8,5,0,NULL)",
+            EndBoundIdBase + id, at, EndBoundServer, "srv" + EndBoundServer.ToString(CultureInfo.InvariantCulture),
+            EndBoundIdBase + id, job, job, at);
+
+    private static async Task CleanupAsync(NpgsqlConnection connection, CancellationToken ct)
+    {
+        await using var jh = new NpgsqlCommand("DELETE FROM job_history WHERE server_id = -556201", connection);
+        await jh.ExecuteNonQueryAsync(ct);
+        await using var svr = new NpgsqlCommand("DELETE FROM servers WHERE server_id = -556201", connection);
+        await svr.ExecuteNonQueryAsync(ct);
+    }
+
+    private static void OnStaThread(Action body)
+    {
+        Exception? error = null;
+        var thread = new Thread(() =>
+        {
+            try { body(); }
+            catch (Exception ex) { error = ex; }
+        });
+        thread.SetApartmentState(ApartmentState.STA);
+        thread.Start();
+        thread.Join();
+
+        if (error is not null)
+        {
+            throw error;
+        }
+    }
+}
diff --git a/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs b/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs
index b786bdf7e5..358cf63eca 100644
--- a/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs
+++ b/Darling/Darling.Tests/ViewerTypedRangeZoneTests.cs
@@ -253,16 +253,17 @@ public void TheOverviewLanesAlwaysGetTheExplicitWindow_SoASubHourSpanIsNotRounde
     }
 
     [Fact]
-    public void TheDataStartNote_IsFedByTheProbeThePrimarySurfacesAlreadyAwait()
+    public void TheDataStartNote_IsFedByTheFloorEveryBannerSiteAlreadyAwaits()
     {
-        var body = StripComments(MemberText(TabSource(), "PrimaryDataStartAsync"));
-
-        Assert.Contains("DataStartOrNullAsync(probe, surface)", body);
-        Assert.Contains("RecordDataStart(floor)", body);
+        /* #5562 R7: the six primary surfaces once awaited their probe through a feeding helper; now every banner site reaches the
+           picker through UpdateTruncationBanner (ViewerTimeRangeGapFixTests pins the site counts and the feed). */
         Assert.Contains("RangePicker.DataStartUtc = floor", StripComments(MemberText(TabSource(), "RecordDataStart")));
+        Assert.DoesNotContain("PrimaryDataStartAsync", TabSource());
         foreach (var file in new[] { "ViewerServerTab.Queries.cs", "ViewerServerTab.ActiveQueries.cs", "ViewerServerTab.Blocking.cs" })
         {
-            Assert.Contains("PrimaryDataStartAsync(", ViewerSource(file, ThisFile()));
+            var code = ViewerSource(file, ThisFile());
+            Assert.Contains("DataStartOrNullAsync(", code);
+            Assert.DoesNotContain("PrimaryDataStartAsync(", code);
         }
     }
 
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml
index c87a509724..e705f4b254 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml
@@ -82,7 +82,7 @@
                        Foreground="{DynamicResource ForegroundBrush}"/>
             <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="5,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
-            <!-- #5562: the shared time range picker. The old "All" (8760 hours) is a typed range now ("365d"). -->
+            <!-- #5562: the shared time range picker. The old "All" (8760 hours) is the picker's longest choice again, the span the alert table keeps (DarlingRetentionHorizons.AlertHistoryRetentionDays, 90 days); the code sets it. -->
             <ui:TimeRangePicker x:Name="TimeRangePickerControl" Compact="True" VerticalAlignment="Center"
                                 RangeChanged="TimeRangePicker_RangeChanged"/>
             <TextBlock Text="Server:" VerticalAlignment="Center" Margin="12,0,4,0"
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs
index e63ce10cf9..12ff8fa5d3 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/AlertsHistoryTab.xaml.cs
@@ -65,6 +65,8 @@ public AlertsHistoryTab()
         /* #5562: the shared picker; the old combo defaulted to the last 24 hours. */
         TimeRangePickerControl.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
         TimeRangePickerControl.Value = TimeRangePresets.Find("1d")!;
+        /* #5562 R8: the old list's "All" is one choice again, the span the alert table keeps (90 days), not a year. */
+        TimeRangePickerControl.SetLongestChoice(ViewerTimeRangeWindow.AlertHistoryLongestChoice, "All");
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
index b7917a53ec..35858f1ea2 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.Loaders.cs
@@ -377,9 +377,10 @@ private static void SetBar(Border bar, ColumnDefinition filled, ColumnDefinition
         empty.Width = new GridLength(Math.Max(100 - clamped, 0.1), GridUnitType.Star);
     }
 
-    /// <summary>The hours-back a FinOps list reads for its picker (#5562): whole hours from the range's start to now, rounded
-    /// up, at least one. These reads take "hours back from now", so a span under an hour reads as one hour, and a range that
-    /// ended in the past reads everything since its start (<see cref="ViewerTimeRangeWindow.HoursBack"/>).</summary>
+    /// <summary>The hours-back a FinOps list reads for its picker (#5562 R5). These reads take "hours back from now", so the
+    /// pickers are rolling-only in whole hours (<see cref="RollingUnitRule"/>): the span is the hours back, exactly. The
+    /// round-up in <see cref="ViewerTimeRangeWindow.HoursBack"/> is only a guard; the picker never offers a finished period
+    /// or a span under an hour.</summary>
     private static int HoursBackFromPicker(TimeRangePicker picker)
     {
         var now = DateTime.UtcNow;
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs
index d13a018e96..6169479d89 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.ObjectHeatmap.cs
@@ -44,8 +44,9 @@ private enum FinOpsStorageDrillLevel { Parent, Objects, Indexes }
     private TextBlock? _finopsObjHeatmapPopupText;
     private DateTime _finopsLastObjHeatmapHover;
 
-    /// <summary>Whole days back for the object heatmap (#5562): the picker's range start to now, rounded up, at least one day.
-    /// The old combo offered 7, 30 and 90 days; the picker's "1mo" is 30, and any other length is typed.</summary>
+    /// <summary>Whole days back for the object heatmap (#5562 R5). The picker is rolling-only in whole days
+    /// (<see cref="RollingUnitRule"/>), so the span is the days back, exactly; the round-up is only a guard. The old combo
+    /// offered 7, 30 and 90 days; the picker's "1mo" is 30, and any other length is typed.</summary>
     private int GetFinOpsObjectHeatmapDaysBack()
     {
         if (FinOpsObjectHeatmapWindowCombo is null)
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs
index f59e5e53d8..0edeefa6f7 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/FinOpsTab.xaml.cs
@@ -58,15 +58,19 @@ public FinOpsTab()
         InitializeComponent();
 
         /* #5562: the shared time range pickers. The old combos opened on 24 hours (the heatmap on 30 days); the pickers
-           open on the same, drawn in the display zone in force. */
+           open on the same, drawn in the display zone in force. Every FinOps read takes "hours back from now" (the heatmap
+           days), so the pickers are rolling-only in whole hours (days): no calendar period, no custom end, no span under
+           one unit (R5). A picker must never offer a range its read cannot honor. */
         foreach (var picker in new[] { FinOpsResourceUsageTimeRangeCombo, FinOpsWaitStatsTimeRangeCombo,
                      FinOpsExpensiveQueriesTimeRangeCombo, FinOpsHighImpactTimeRangeCombo })
         {
             picker.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
+            picker.RollingUnit = RollingUnitRule.Hour;
             picker.Value = TimeRangePresets.Find("1d")!;
         }
 
         FinOpsObjectHeatmapWindowCombo.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
+        FinOpsObjectHeatmapWindowCombo.RollingUnit = RollingUnitRule.Day;
         FinOpsObjectHeatmapWindowCombo.Value = TimeRangePresets.Find("1mo")!;
 
         /* Register the FinOps grids' column-filter managers into _filterManagers (defined below), after
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
index 5a3b5fd675..a2cf39ae36 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
@@ -90,6 +90,16 @@ public void Initialize(ViewerDataService dataService)
     internal static Task ShowJobHistoryDataStartAsync(TextBlock banner, Task<DateTime?> probe, DateTime startUtc, IEnumerable<ViewerJobHistoryRow> read) =>
         ViewerServerTab.ShowEventDataStartAsync(banner, probe, "Job History", startUtc, read.Select(r => r.RunDateTimeUtc), RowCap);
 
+    /// <summary>Sets the picker's "Data starts ..." note from the data-start probe the tab already awaited (#5562 R7): the floor its
+    /// "Showing since" banner reads, fed by <see cref="ViewerServerTab.UpdateTruncationBanner"/>. No query of its own.</summary>
+    internal void RecordDataStart(DateTime? floor)
+    {
+        if (TimeRangePickerControl.DataStartUtc != floor)
+        {
+            TimeRangePickerControl.DataStartUtc = floor;
+        }
+    }
+
     private async Task LoadJobsAsync()
     {
         if (_dataService == null)
@@ -116,18 +126,11 @@ never the grid. */
             using var readFanOut = ViewerReadFanOut.Of(2);
             var dataStartTask = _dataService.GetJobHistoryDataStartAsync(serverId, sinceUtc, nowUtc);
 
-            var readTask = _dataService.GetJobHistoryAsync(sinceUtc, serverId, RowCap);
+            /* #5562 R6: a range that ended in the past sends its end to the read, so the end bound is applied before the row cap. */
+            var readTask = _dataService.GetJobHistoryAsync(sinceUtc, serverId, RowCap, untilUtc: windowIsLive ? null : windowEndUtc);
             await ViewerServerTab.AwaitReadWatchingProbeAsync(readTask, dataStartTask, "Job History");
             var all = await readTask;
             readFanOut.Release();
-            if (!windowIsLive)
-            {
-                /* #5562: the read is start-only (newest first, capped), so a range that ended in the past drops the runs after
-                   its end here. A finished range inside a busy fleet's newest 2,000 runs is exact; beyond that the cap note says
-                   the list is the newest N of everything since the start. */
-                all = all.Where(r => r.RunDateTimeUtc is not { } ran || ran < windowEndUtc).ToList();
-            }
-
             if (_loads.Superseded(nameof(LoadJobsAsync), gen)) return;
 
             /* Populate the Server / Category combos from the full (pre status/category) result, then apply
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.JobHistory.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.JobHistory.cs
index 48e87a70a7..6279b12ea6 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.JobHistory.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataService.JobHistory.cs
@@ -172,10 +172,15 @@ public sealed partial class ViewerDataService
     /// </para>
     /// </summary>
     public async Task<List<ViewerJobHistoryRow>> GetJobHistoryAsync(
-        DateTime sinceUtc, int? serverId = null, int limit = 2000, CancellationToken cancellationToken = default)
+        DateTime sinceUtc, int? serverId = null, int limit = 2000, DateTime? untilUtc = null, CancellationToken cancellationToken = default)
     {
+        /* #5562 R6: a finished range's end goes into the read (the shared reader's UntilUtc), so the SQL bounds the runs before the
+           per-server top-N and the row cap count them. A window that ended in the past on a busy fleet keeps every run inside it, not
+           the newest N of everything since the start. The reader's end is inclusive; the picker's end is exclusive (a run at the next
+           day's start is not in "yesterday"), so it is taken one microsecond (the store's precision) earlier. */
+        var filter = untilUtc is { } until ? new JobHistoryFilter(UntilUtc: until.AddTicks(-TimeSpan.TicksPerMicrosecond)) : null;
         var dtos = await DarlingJobHistoryReader.GetAsync(
-            _dataSource, sinceUtc, serverId, limit, ViewerCommandDeadlines.CurrentInteractiveReadSeconds, cancellationToken: cancellationToken);
+            _dataSource, sinceUtc, serverId, limit, ViewerCommandDeadlines.CurrentInteractiveReadSeconds, filter, cancellationToken);
 
         /* D5: each row converts on its own server's clock, read from the fleet's held clocks (ServerClockCache), the way
            Alert History's rows do, not on whichever server tab happens to be active. */
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataStartNote.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataStartNote.cs
new file mode 100644
index 0000000000..366c5b3b8c
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerDataStartNote.cs
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Media.Media3D;
+
+namespace PerformanceMonitor.Darling.Viewer;
+
+/// <summary>
+/// Feeds the time range picker's "Data starts ..." note from a "Showing since" banner site (#5562 R7). Every banner on the
+/// server tab, and Job History's, goes through <see cref="ViewerServerTab.UpdateTruncationBanner"/> (the event surfaces through
+/// <see cref="ViewerServerTab.ShowEventDataStartAsync"/>, which ends in it), so that one method hands its floor here: the answer
+/// of the data-start probe the site already awaited, with no query of its own. The floor reaches the picker of the tab the
+/// banner sits in, and only while the banner is on screen: the content of a tab that is not selected has no parent in the
+/// visual tree, so a banner of a background tab never moves the note of the tab in front.
+/// </summary>
+internal static class ViewerDataStartNote
+{
+    /// <summary>Hands <paramref name="floor"/> to the picker of the tab that holds <paramref name="banner"/>, if the banner is on
+    /// screen in one. A banner outside any tab (a test's bare control, a detached tab) feeds nothing.</summary>
+    internal static void Feed(DependencyObject banner, DateTime? floor)
+    {
+        for (var node = ParentOf(banner); node is not null; node = ParentOf(node))
+        {
+            switch (node)
+            {
+                case ViewerServerTab serverTab:
+                    serverTab.RecordDataStart(floor);
+                    return;
+                case JobHistoryTab jobHistory:
+                    jobHistory.RecordDataStart(floor);
+                    return;
+            }
+        }
+    }
+
+    /// <summary>The first ancestor of <paramref name="start"/> that is a <typeparamref name="T"/>, by the visual tree (the logical
+    /// tree for a node that is not a visual), or null. The walk <see cref="Feed"/> makes, generic so a test can run it on plain
+    /// panels.</summary>
+    internal static T? FindAncestor<T>(DependencyObject start) where T : DependencyObject
+    {
+        for (var node = ParentOf(start); node is not null; node = ParentOf(node))
+        {
+            if (node is T found)
+            {
+                return found;
+            }
+        }
+
+        return null;
+    }
+
+    /* The visual parent, so the content of a tab that is not selected (not connected to the visual tree) ends the walk: its logical
+       parent is its TabItem, which would feed a background tab's floor to the tab in front. */
+    private static DependencyObject? ParentOf(DependencyObject node) =>
+        node is Visual or Visual3D ? VisualTreeHelper.GetParent(node) : LogicalTreeHelper.GetParent(node);
+}
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs
index ae475ff8a2..75fa630c62 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.ActiveQueries.cs
@@ -96,7 +96,7 @@ read. Honor a pending deep-link window instead so a concurrent activation load u
         var (totalCount, snapshots) = dataReadTask.Result;
         _querySnapshotsFilterMgr!.UpdateData(snapshots);
         LatestSnapshotIndicator.Text = snapshots.Count < totalCount ? $"Showing the newest 1,000 of {totalCount:N0}" : "";
-        UpdateTruncationBanner(QuerySnapshotsTruncationBanner, await PrimaryDataStartAsync(dataStartTask, "Active Queries"), startUtc);
+        UpdateTruncationBanner(QuerySnapshotsTruncationBanner, await DataStartOrNullAsync(dataStartTask, "Active Queries"), startUtc);
         await LoadActiveQueriesSlicerAsync(startUtc, endUtc);
     }
 
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs
index 11c609dbb4..ea4f05211a 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Blocking.cs
@@ -234,7 +234,7 @@ covers them. */
                 var blocked = await blockedTask;
                 RenderCurrentWaitsDurationChart(duration);
                 RenderCurrentWaitsBlockedChart(blocked);
-                UpdateTruncationBanner(CurrentWaitsTruncationBanner, await PrimaryDataStartAsync(dataStartTask, "Current Waits"), startUtc);
+                UpdateTruncationBanner(CurrentWaitsTruncationBanner, await DataStartOrNullAsync(dataStartTask, "Current Waits"), startUtc);
                 break;
             }
             case BlockedProcessReportsSubTabIndex:
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs
index 50e63ad0c5..c7395a345c 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Postgres.cs
@@ -191,7 +191,7 @@ private async Task LoadPgCpuUtilizationAsync(DateTime startUtc, DateTime endUtc)
         readFanOut.Release();
 
         PgCpuGrid.ItemsSource = rows;
-        UpdateTruncationBanner(PgCpuDataStartBanner, await PrimaryDataStartAsync(dataStartTask, "PostgreSQL CPU"), startUtc);
+        UpdateTruncationBanner(PgCpuDataStartBanner, await DataStartOrNullAsync(dataStartTask, "PostgreSQL CPU"), startUtc);
         PgCpuNote.Text = PanelNote("pg_cpu_utilization", rows.Count,
             "This collector samples AWS Performance Insights on a 5-minute cadence, so a server added "
             + "recently may have nothing here yet.");
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs
index 0c8866dc6d..dc2359d7b4 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.Queries.cs
@@ -186,7 +186,7 @@ private async Task LoadTopQueriesAsync(DateTime startUtc, DateTime endUtc)
            ViewerDataService.GetTopQueriesByCpuTierAsync) — the raw-floor banner (#4231 stage 1/2) and this
            tier disclosure are independent facts, so both may show at once (a window aged past raw AND
            routed to hourly). */
-        UpdateTruncationBanner(QueryStatsTruncationBanner, await PrimaryDataStartAsync(floorTask, "Query Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
+        UpdateTruncationBanner(QueryStatsTruncationBanner, await DataStartOrNullAsync(floorTask, "Query Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
         await LoadQueryStatsSlicerAsync(startUtc, endUtc);
         await RefreshQueryStatsComparisonAsync(startUtc, endUtc);
     }
@@ -238,7 +238,7 @@ private async Task LoadTopProceduresAsync(DateTime startUtc, DateTime endUtc)
         SetDefaultSortIfNone(ProcedureStatsGrid, "TotalElapsedMs", ListSortDirection.Descending);
         /* #4231 stage 3b: an hourly-routed page holds no object_type/sql_handle/plan_handle — the raw-floor
            banner and this tier disclosure are independent facts, same reasoning as the Queries sub-tab. */
-        UpdateTruncationBanner(ProcStatsTruncationBanner, await PrimaryDataStartAsync(floorTask, "Procedure Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
+        UpdateTruncationBanner(ProcStatsTruncationBanner, await DataStartOrNullAsync(floorTask, "Procedure Stats"), startUtc, HourlyBannerSuffix(read.Tier, read.IoRoute, read.HourlyEdgesNote), HourlyServedOf(read.Tier, read.HourlyFirstBucket));
         await LoadProcStatsSlicerAsync(startUtc, endUtc);
         await RefreshProcStatsComparisonAsync(startUtc, endUtc);
     }
@@ -255,7 +255,7 @@ ordinary read (M1) — null tells the gate this end is open. */
         var (rows, widePlan) = dataReadTask.Result;
         _queryStoreFilterMgr!.UpdateData(rows);
         SetDefaultSortIfNone(QueryStoreGrid, "TotalDurationMs", ListSortDirection.Descending);
-        UpdateTruncationBanner(QueryStoreTruncationBanner, await PrimaryDataStartAsync(floorTask, "Query Store"), startUtc, widePlan: widePlan);
+        UpdateTruncationBanner(QueryStoreTruncationBanner, await DataStartOrNullAsync(floorTask, "Query Store"), startUtc, widePlan: widePlan);
         await LoadQueryStoreSlicerAsync(startUtc, endUtc);
         await RefreshQueryStoreComparisonAsync(startUtc, endUtc);
     }
@@ -271,6 +271,10 @@ ordinary read (M1) — null tells the gate this end is open. */
     internal static void UpdateTruncationBanner(TextBlock banner, DateTime? floor, DateTime requestedStartUtc, string? tierSuffix = null,
         HourlyServed? hourly = null, QueryStoreIntervalWide.WideReadPlan? widePlan = null)
     {
+        /* #5562 R7: every banner site's floor (the probe answer the site already awaited) also feeds the picker's "Data starts"
+           note of the tab the banner is on screen in. One feed here covers each site, the event surfaces included. */
+        ViewerDataStartNote.Feed(banner, floor);
+
         /* #4689: when the interval table served, the rows start at the plan's EffectiveStart, not at raw's
            floor. The banner names that start and the bound that set it; the slicer still reads raw, so a
            truncated raw floor is named beside it. The raw route's banner below is unchanged.
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
index cce987b79a..c92ad07a88 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
@@ -215,7 +215,8 @@ read at most every five minutes. */
     /// <summary>
     /// Sets the picker's "Data starts ..." note from a data-start probe a surface already awaited (#5562, the desktop twin
     /// of the web's retention note): the same <c>floor</c> the surface's "Showing since" banner reads. No query of its own.
-    /// A null floor (the probe found nothing, or failed) clears the note.
+    /// Every banner site reaches it through <see cref="UpdateTruncationBanner"/> and <see cref="ViewerDataStartNote.Feed"/>
+    /// (#5562 R7), for the tab on screen. A null floor (the probe found nothing, or failed) clears the note.
     /// </summary>
     internal void RecordDataStart(DateTime? floor)
     {
@@ -225,15 +226,6 @@ internal void RecordDataStart(DateTime? floor)
         }
     }
 
-    /// <summary><see cref="DataStartOrNullAsync"/> that also feeds the picker's data-start note with its answer. Used by the
-    /// primary surface of each top-level tab.</summary>
-    private async Task<DateTime?> PrimaryDataStartAsync(Task<DateTime?> probe, string surface)
-    {
-        var floor = await DataStartOrNullAsync(probe, surface);
-        RecordDataStart(floor);
-        return floor;
-    }
-
     private async void RefreshDataButton_Click(object sender, RoutedEventArgs e)
     {
         RefreshDataButton.IsEnabled = false;
@@ -425,7 +417,6 @@ public void SetDisplayModeSelection(TimeDisplayMode mode)
         }
     }
 
-    /// <summary>
     /// <summary>
     /// Applies a range chosen on another server tab (the "Apply to All" broadcast). The range arrives as a spec whose
     /// instants are already fixed where they must be (<see cref="ViewerTimeRangeWindow.ForBroadcast"/>): this tab holds
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
index a1e6f19241..17705b1636 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
@@ -9,6 +9,7 @@
 using System;
 using System.Collections.Generic;
 using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Darling.Storage;
 using PerformanceMonitor.Ui;
 
 namespace PerformanceMonitor.Darling.Viewer;
@@ -126,6 +127,12 @@ internal static TimeRangeSpec ForBroadcast(TimeRangeSpec spec, DateTime nowUtc,
         return minutes is > 0 ? TimeSpan.FromMinutes(minutes.Value) : null;
     }
 
+    /// <summary>The longest choice Alert History offers (#5562 R8), the "All" the old list had: a span equal to what the alert
+    /// table keeps, <see cref="DarlingRetentionHorizons.AlertHistoryRetentionDays"/> (90 days; <c>config_alert_log</c> is purged
+    /// past it), and never longer than a year when that retention is raised. A longer range would only read the same rows.</summary>
+    internal static TimeRangeSpec AlertHistoryLongestChoice { get; } =
+        TimeRangeSpec.Relative(TimeSpan.FromDays(Math.Min(DarlingRetentionHorizons.AlertHistoryRetentionDays, 365)));
+
     /// <summary>The range a newly-opened tab starts on, from the persisted preference (a string id wins; the legacy
     /// index stands in for a file written before the string existed).</summary>
     internal static TimeRangeSpec DefaultFor(ViewerPreferences preferences)
diff --git a/PerformanceMonitor.Ui/TimeRange/RollingUnitRule.cs b/PerformanceMonitor.Ui/TimeRange/RollingUnitRule.cs
new file mode 100644
index 0000000000..f4546f978c
--- /dev/null
+++ b/PerformanceMonitor.Ui/TimeRange/RollingUnitRule.cs
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+using System;
+
+namespace PerformanceMonitor.Ui;
+
+/// <summary>
+/// Which ranges a "rolling only" picker admits (#5562 R5). A read that takes "N hours (or days) back from now" can
+/// honor only a length counted back from now, in whole units, of at least one unit. A calendar period, a fixed range
+/// or a "since" range would read through now, and 90 minutes would read as 2 hours, so the picker must never offer
+/// them. Pure, so a test pins the rule without a window.
+/// </summary>
+public static class RollingUnitRule
+{
+    /// <summary>The one hour unit of the FinOps lists.</summary>
+    public static readonly TimeSpan Hour = TimeSpan.FromHours(1);
+
+    /// <summary>The one day unit of the FinOps object heatmap.</summary>
+    public static readonly TimeSpan Day = TimeSpan.FromDays(1);
+
+    /// <summary>Why <paramref name="spec"/> is not a range a read in whole <paramref name="unit"/>s can honor, or <c>null</c> when it is.</summary>
+    public static string? Refusal(TimeRangeSpec spec, TimeSpan unit)
+    {
+        ArgumentNullException.ThrowIfNull(spec);
+        var name = unit == Day ? "day" : "hour";
+        if (spec.Kind != TimeRangeKind.Relative)
+        {
+            return "This read takes a length back from now, such as " + (unit == Day ? "7d or 30 days" : "4h or 3 days") + ".";
+        }
+
+        if (spec.Span < unit)
+        {
+            return "The shortest range for this read is 1 " + name + ".";
+        }
+
+        if (spec.Span.Ticks % unit.Ticks != 0)
+        {
+            var whole = TimeSpan.FromTicks((spec.Span.Ticks / unit.Ticks + 1) * unit.Ticks);
+            return "This read takes whole " + name + "s; try " + TimeRangeSpec.FormatLength(whole) + ".";
+        }
+
+        return null;
+    }
+
+    /// <summary>True when a read in whole <paramref name="unit"/>s can honor <paramref name="spec"/>.</summary>
+    public static bool Admits(TimeRangeSpec spec, TimeSpan unit) => Refusal(spec, unit) is null;
+}
diff --git a/PerformanceMonitor.Ui/TimeRangePicker.xaml b/PerformanceMonitor.Ui/TimeRangePicker.xaml
index 2d7716003d..82ef99a148 100644
--- a/PerformanceMonitor.Ui/TimeRangePicker.xaml
+++ b/PerformanceMonitor.Ui/TimeRangePicker.xaml
@@ -68,7 +68,7 @@
                         <TextBlock Text="Past" FontWeight="SemiBold" Margin="0,0,0,4"
                                    Foreground="{DynamicResource ForegroundDimBrush}"/>
                         <WrapPanel x:Name="RollingPanel"/>
-                        <TextBlock Text="Calendar" FontWeight="SemiBold" Margin="0,10,0,4"
+                        <TextBlock x:Name="CalendarHeader" Text="Calendar" FontWeight="SemiBold" Margin="0,10,0,4"
                                    Foreground="{DynamicResource ForegroundDimBrush}"/>
                         <StackPanel x:Name="PeriodPanel"/>
                     </StackPanel>
diff --git a/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs b/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
index 9e38f76a0e..85b3aefbd4 100644
--- a/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
+++ b/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
@@ -57,6 +57,8 @@ public partial class TimeRangePicker : UserControl
     private DateTime? _dataStartUtc;
     private TimeSpan? _sampleInterval;
     private bool _compact;
+    private TimeSpan? _rollingUnit;
+    private Button? _longestButton;
     private long _closedAtTick;
     private TimeRangeParseResult? _typed;
     private Func<TimeZoneInfo>? _zoneProvider;
@@ -158,6 +160,80 @@ public bool Compact
         }
     }
 
+    /// <summary>
+    /// Makes the picker rolling-only, in whole units of this length (#5562 R5): one hour for a FinOps list, one day for the
+    /// object heatmap. These reads take "N units back from now", so the picker offers no calendar period, no custom end and no
+    /// "since" range, no preset or typed length under one unit, and no length that is not a whole number of units
+    /// (<see cref="RollingUnitRule"/>). Null (the default) offers everything.
+    /// </summary>
+    public TimeSpan? RollingUnit
+    {
+        get => _rollingUnit;
+        set
+        {
+            if (value is { } unit && unit <= TimeSpan.Zero)
+            {
+                throw new ArgumentOutOfRangeException(nameof(value), "A rolling unit is positive.");
+            }
+
+            _rollingUnit = value;
+            var calendar = value is null ? Visibility.Visible : Visibility.Collapsed;
+            CalendarHeader.Visibility = calendar;
+            PeriodPanel.Visibility = calendar;
+            PickCalendar.Visibility = calendar;
+            UpdateRollingButtons();
+            Refresh();
+        }
+    }
+
+    /// <summary>
+    /// Adds one more rolling choice after the presets, for a surface whose data has a natural longest span (#5562 R8): Alert
+    /// History's "All" is the span its table keeps. Pass <c>null</c> to remove it. A rolling-only picker still refuses it when its
+    /// unit does not fit (<see cref="RollingUnit"/>).
+    /// </summary>
+    /// <param name="spec">The span the choice selects.</param>
+    /// <param name="label">The button text, such as "All".</param>
+    public void SetLongestChoice(TimeRangeSpec? spec, string label = "All")
+    {
+        if (_longestButton is not null)
+        {
+            RollingPanel.Children.Remove(_longestButton);
+            _rollingButtons.RemoveAll(entry => ReferenceEquals(entry.Button, _longestButton));
+            _longestButton = null;
+        }
+
+        if (spec is not null)
+        {
+            var button = new Button
+            {
+                Content = label,
+                MinWidth = 40,
+                Padding = new Thickness(6, 3, 6, 3),
+                Margin = new Thickness(0, 0, 4, 4),
+                Tag = spec
+            };
+            AutomationProperties.SetName(button, label + " (" + spec.Name + ")");
+            button.Click += Preset_Click;
+            RollingPanel.Children.Add(button);
+            _rollingButtons.Add((button, spec));
+            _longestButton = button;
+        }
+
+        UpdateRollingButtons();
+        Refresh();
+    }
+
+    /// <summary>Why this picker cannot take <paramref name="spec"/> (rolling-only form), or <c>null</c> when it can.</summary>
+    public string? Refusal(TimeRangeSpec spec)
+    {
+        if (_rollingUnit is not { } unit)
+        {
+            return null;
+        }
+
+        return RollingUnitRule.Refusal(spec, unit);
+    }
+
     /// <summary>True while the popup is open.</summary>
     public bool IsPopupOpen => PickerPopup.IsOpen;
 
@@ -169,7 +245,7 @@ public bool Compact
     public bool Select(TimeRangeSpec spec)
     {
         ArgumentNullException.ThrowIfNull(spec);
-        if (!spec.TryResolve(NowUtc, Zone, out var range, out _))
+        if (Refusal(spec) is not null || !spec.TryResolve(NowUtc, Zone, out var range, out _))
         {
             return false;
         }
@@ -273,6 +349,17 @@ private void BuildPresetButtons()
         }
     }
 
+    /// <summary>Greys the rolling presets a rolling-only picker cannot take (under one unit); a plain picker enables them all.</summary>
+    private void UpdateRollingButtons()
+    {
+        foreach (var (button, spec) in _rollingButtons)
+        {
+            var refusal = Refusal(spec);
+            button.IsEnabled = refusal is null;
+            button.ToolTip = refusal ?? spec.Name;
+        }
+    }
+
     /// <summary>Fills each period's current length ("3d") from the clock and zone, and greys one that is under the minimum right now.</summary>
     private void RefreshPeriodLengths()
     {
@@ -406,12 +493,23 @@ private void UpdateEcho()
         {
             _typed = null;
             ApplyButton.IsEnabled = false;
-            EchoText.Text = "Examples: 45m, 3 days, last month, Oct 1 - Oct 2, 1:00 am - 7:00 am, since 10/1";
+            EchoText.Text = _rollingUnit is null
+                ? "Examples: 45m, 3 days, last month, Oct 1 - Oct 2, 1:00 am - 7:00 am, since 10/1"
+                : "Examples: 4h, 3 days, 2 weeks";
             EchoText.SetResourceReference(TextBlock.ForegroundProperty, "ForegroundDimBrush");
             return;
         }
 
         _typed = TimeRangeParser.Parse(text, NowUtc, Zone);
+        if (_typed.Ok && _typed.Spec is { } typedSpec && Refusal(typedSpec) is { } refusal)
+        {
+            _typed = null;
+            EchoText.Text = refusal;
+            EchoText.SetResourceReference(TextBlock.ForegroundProperty, "ErrorBrush");
+            ApplyButton.IsEnabled = false;
+            return;
+        }
+
         if (_typed.Ok)
         {
             var notes = NotesFor(_typed.Range!);

From cddfeaf364a89ee09e5018aa624761b0e0949284 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:09:09 -0400
Subject: [PATCH 14/33] Lite: FinOps pickers rolling only, Job History and
 Alert History end bounds, Alert History longest span (#5562)

---
 Lite/Controls/AlertsHistoryTab.xaml.cs        | 20 +++--
 Lite/Controls/FinOpsTab.xaml.cs               |  6 ++
 Lite/Controls/JobHistoryTab.xaml.cs           | 14 +--
 Lite/Helpers/LiteTimeRange.cs                 | 61 +++++++++++++
 .../Services/LocalDataService.AlertHistory.cs | 89 +++++++++++++++----
 Lite/Services/LocalDataService.JobHistory.cs  | 51 ++++++++---
 6 files changed, 194 insertions(+), 47 deletions(-)

diff --git a/Lite/Controls/AlertsHistoryTab.xaml.cs b/Lite/Controls/AlertsHistoryTab.xaml.cs
index 3a09605bd7..63a7d41ed6 100644
--- a/Lite/Controls/AlertsHistoryTab.xaml.cs
+++ b/Lite/Controls/AlertsHistoryTab.xaml.cs
@@ -63,6 +63,8 @@ public AlertsHistoryTab()
     {
         InitializeComponent();
         RangePicker.Value = TimeRangePresets.FromLegacyHours(24)!; /* 24 hours, as the list opened */
+        /* R8: the old "All" item is a typed span as long as the alert log is kept (3 months on Lite, RetentionService.ArchiveRetentionMonths). */
+        RangePicker.ToolTip = $"Alerts are kept for {RetentionService.ArchiveRetentionMonths} months: type {LiteTimeRange.AlertHistoryLongestText(DateTime.UtcNow)} to see them all.";
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
@@ -118,7 +120,7 @@ private async System.Threading.Tasks.Task LoadAlertsAsync()
 
         try
         {
-            var hoursBack = GetSelectedHoursBack();
+            var (sinceUtc, untilUtc) = GetSelectedWindow();
             int? serverId = GetSelectedServerId();
 
             /* #4766: the rows and each server's collected clock come back from ONE hop off the UI thread, and the
@@ -126,7 +128,7 @@ private async System.Threading.Tasks.Task LoadAlertsAsync()
             var dataService = _dataService;
             var (alerts, collectedClocks) = await System.Threading.Tasks.Task.Run(async () =>
             {
-                var rows = await dataService.GetAlertHistoryAsync(hoursBack, RowCap, serverId);
+                var rows = await dataService.GetAlertHistoryWindowAsync(sinceUtc, untilUtc, serverId, RowCap);
                 return (rows, await ReadCollectedClocksAsync(dataService, rows));
             });
             if (_loads.Superseded(nameof(LoadAlertsAsync), gen)) return;
@@ -135,7 +137,7 @@ private async System.Threading.Tasks.Task LoadAlertsAsync()
             StampClocks(alerts, collectedClocks, _openTabClock);
 
             var displayCount = ShowAlerts(alerts);
-            AppLogger.Debug("AlertsHistory", $"Loaded {displayCount} alert(s) (query returned {alerts.Count}, hoursBack={hoursBack}, serverId={serverId?.ToString() ?? "all"})");
+            AppLogger.Debug("AlertsHistory", $"Loaded {displayCount} alert(s) (query returned {alerts.Count}, since={sinceUtc:O}, until={(untilUtc.HasValue ? untilUtc.Value.ToString("O") : "now")}, serverId={serverId?.ToString() ?? "all"})");
 
             _lastRefreshed = DateTime.UtcNow;
             UpdateStaleDataIndicator();
@@ -252,10 +254,9 @@ private void PopulateServerFilter(List<AlertHistoryRow> alerts)
         ServerFilterComboBox.SelectionChanged += ServerFilterComboBox_SelectionChanged;
     }
 
-    private int GetSelectedHoursBack()
-    {
-        return LiteTimeRange.HoursBackOf(RangePicker, 24);
-    }
+    /// <summary>The picker's window for the read and for Dismiss All (#5562): the start and, for a range that has finished, its exclusive end (null while it runs to now).</summary>
+    private (DateTime sinceUtc, DateTime? untilUtc) GetSelectedWindow()
+        => LiteTimeRange.BoundsOf(RangePicker, 24, DateTime.UtcNow);
 
     private int? GetSelectedServerId()
     {
@@ -483,9 +484,10 @@ private async void DismissAll_Click(object sender, RoutedEventArgs e)
 
         try
         {
-            var hoursBack = GetSelectedHoursBack();
+            /* The same window the grid read (#5562): a range that ended in the past dismisses only the rows up to its end. */
+            var (sinceUtc, untilUtc) = GetSelectedWindow();
             int? serverId = GetSelectedServerId();
-            var affected = await System.Threading.Tasks.Task.Run(() => _dataService.DismissAllVisibleAlertsAsync(hoursBack, serverId));
+            var affected = await System.Threading.Tasks.Task.Run(() => _dataService.DismissAllVisibleAlertsWindowAsync(sinceUtc, untilUtc, serverId));
             if (affected < liveCount && App.LogAlertDismissals)
             {
                 AppLogger.Warn("AlertsHistory", $"Dismiss all: only {affected} of {liveCount} live alert(s) were updated");
diff --git a/Lite/Controls/FinOpsTab.xaml.cs b/Lite/Controls/FinOpsTab.xaml.cs
index b616977223..02646bf63a 100644
--- a/Lite/Controls/FinOpsTab.xaml.cs
+++ b/Lite/Controls/FinOpsTab.xaml.cs
@@ -81,6 +81,12 @@ public FinOpsTab()
     {
         InitializeComponent();
         /* #5562: every list opened on the last 24 hours (1d); the heatmap on 30 days (1mo). */
+        /* R5: the lists and the heatmap read "hours back from now", so each picker is rolling only (the heatmap in whole days). */
+        LiteTimeRange.ConfigureFinOpsPicker(ResourceUsageTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
+        LiteTimeRange.ConfigureFinOpsPicker(WaitStatsTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
+        LiteTimeRange.ConfigureFinOpsPicker(ExpensiveQueriesTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
+        LiteTimeRange.ConfigureFinOpsPicker(HighImpactTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
+        LiteTimeRange.ConfigureFinOpsPicker(ObjectHeatmapWindowPicker, LiteTimeRange.FinOpsHeatmapMinSpan);
         var day = TimeRangePresets.FromLegacyHours(24)!;
         ResourceUsageTimeRangePicker.Value = day;
         WaitStatsTimeRangePicker.Value = day;
diff --git a/Lite/Controls/JobHistoryTab.xaml.cs b/Lite/Controls/JobHistoryTab.xaml.cs
index 011c1fd592..7761b26cf7 100644
--- a/Lite/Controls/JobHistoryTab.xaml.cs
+++ b/Lite/Controls/JobHistoryTab.xaml.cs
@@ -93,17 +93,16 @@ starting of two overlapping reads can land first. Same idiom as FinOpsTab's. */
 
         try
         {
-            var hoursBack = GetSelectedHoursBack();
             int? serverId = GetSelectedServerId();
 
             /* #4966: the window's start is worked out ONCE, and the read and the data-start probe both take that instant: the note is
                worded against the window the rows were read over. The open tabs' clocks are taken here, on the UI thread (they are
                UI objects), and the read gets them as a plain snapshot. */
             var nowUtc = DateTime.UtcNow;
-            var startUtc = nowUtc.AddHours(-hoursBack);
+            var (startUtc, rangeEndUtc) = LiteTimeRange.BoundsOf(RangePicker, 24, nowUtc);
             var openTabClocks = _openTabClocks?.Invoke();
 
-            var (all, readClocks) = await System.Threading.Tasks.Task.Run(() => _dataService.GetJobHistoryWithClocksAsync(startUtc, RowCap, serverId, openTabClocks));
+            var (all, readClocks) = await System.Threading.Tasks.Task.Run(() => _dataService.GetJobHistoryWithClocksAsync(startUtc, RowCap, serverId, openTabClocks, rangeEndUtc));
             if (_loads.Superseded(nameof(LoadJobsAsync), gen)) return;
 
             /* #2126: rows carry the raw collected server name; swap in the operator's alias where the
@@ -148,7 +147,7 @@ other tab. A server no longer in config keeps its raw name (the durable-record c
                a Status/Category filter narrowing the grid must not make the "newest 2,000" label disappear when
                the underlying read still hit the cap. */
             JobCountIndicator.Text = JobHistoryCap.CountText(displayCount, all.Count, RowCap);
-            AppLogger.Debug("JobHistory", $"Loaded {displayCount} job run(s) (query returned {all.Count}, hoursBack={hoursBack}, serverId={serverId?.ToString() ?? "all"})");
+            AppLogger.Debug("JobHistory", $"Loaded {displayCount} job run(s) (query returned {all.Count}, since={startUtc:O}, until={(rangeEndUtc.HasValue ? rangeEndUtc.Value.ToString("O") : "now")}, serverId={serverId?.ToString() ?? "all"})");
 
             _lastRefreshed = DateTime.UtcNow;
             UpdateStaleDataIndicator();
@@ -161,7 +160,7 @@ the underlying read still hit the cap. */
             /* #4966: the rows are bound and the loading note is down; the note comes last, from the UNFILTERED read (all): the Status
                and Category filters narrow the grid on the client and say nothing about where the data starts. A probe that fails
                costs the note and never the grid. */
-            await ShowDataStartNoteAsync(serverId, readClocks, startUtc, nowUtc, all, gen);
+            await ShowDataStartNoteAsync(serverId, readClocks, startUtc, rangeEndUtc ?? nowUtc, all, gen);
         }
         catch (Exception ex)
         {
@@ -416,11 +415,6 @@ private void PopulateCategoryFilter(List<JobHistoryRow> rows)
         CategoryFilterComboBox.SelectionChanged += Filter_SelectionChanged;
     }
 
-    private int GetSelectedHoursBack()
-    {
-        return LiteTimeRange.HoursBackOf(RangePicker, 24);
-    }
-
     private int? GetSelectedServerId()
     {
         if (ServerFilterComboBox.SelectedIndex > 0 &&
diff --git a/Lite/Helpers/LiteTimeRange.cs b/Lite/Helpers/LiteTimeRange.cs
index 8deed821f8..c776d88605 100644
--- a/Lite/Helpers/LiteTimeRange.cs
+++ b/Lite/Helpers/LiteTimeRange.cs
@@ -19,6 +19,23 @@ namespace PerformanceMonitorLite.Helpers;
 /// </summary>
 internal static class LiteTimeRange
 {
+    /// <summary>The shortest FinOps list range: every FinOps read is whole hours back from now (#5562 R5).</summary>
+    internal static readonly TimeSpan FinOpsMinSpan = TimeSpan.FromHours(1);
+
+    /// <summary>The shortest heatmap window: the heatmap reads whole days.</summary>
+    internal static readonly TimeSpan FinOpsHeatmapMinSpan = TimeSpan.FromDays(1);
+
+    /// <summary>
+    /// A FinOps picker (#5562 R5): compact, rolling only (no calendar period, no start-and-end, no 'since') and at least
+    /// <paramref name="minSpan"/>, because the read behind it is "hours back from now" and could not honor a finished range.
+    /// </summary>
+    internal static void ConfigureFinOpsPicker(TimeRangePicker picker, TimeSpan minSpan)
+    {
+        picker.Compact = true;
+        picker.RollingOnly = true;
+        picker.MinSpan = minSpan;
+    }
+
     /// <summary>The range a fresh install opens on: the old default of four hours.</summary>
     internal static TimeRangeSpec Default => TimeRangeSpec.Relative(TimeSpan.FromHours(4));
 
@@ -57,6 +74,50 @@ internal static int HoursBackOf(TimeRangePicker picker, int fallbackHours)
         return range != null ? WindowFor(range).hoursBack : fallbackHours;
     }
 
+    /// <summary>
+    /// The window a history read takes: the picker's start and, for a range that has finished, its exclusive end (#5562).
+    /// A rolling or live range ('Past 24 hours', 'Today', 'since X') has no end bound (<c>null</c>), so rows collected after
+    /// <paramref name="nowUtc"/> are never cut. <paramref name="fallbackHours"/> when the held range cannot be used right now.
+    /// </summary>
+    internal static (DateTime startUtc, DateTime? endUtc) BoundsOf(TimeRangePicker picker, int fallbackHours, DateTime nowUtc)
+    {
+        var range = picker.Resolve();
+        if (range == null)
+        {
+            return (nowUtc.AddHours(-fallbackHours), null);
+        }
+
+        return BoundsOf(range, nowUtc);
+    }
+
+    /// <summary><see cref="BoundsOf(TimeRangePicker, int, DateTime)"/> for a range already resolved.</summary>
+    internal static (DateTime startUtc, DateTime? endUtc) BoundsOf(ResolvedTimeRange range, DateTime nowUtc)
+    {
+        if (range.Spec.WholeHours is { } hours && hours > 0)
+        {
+            return (nowUtc.AddHours(-hours), null);
+        }
+
+        return (range.StartUtc, range.IsLive ? null : range.EndUtc);
+    }
+
+    /// <summary>
+    /// The longest span Alert History offers (#5562 R8; the old "All" item is gone): a typed length equal to how long Lite keeps
+    /// the alert log, 365 days at most. The alert log is archived like every signal table and its archive files are deleted
+    /// <see cref="RetentionService.ArchiveRetentionMonths"/> months back (RetentionService.cs:34), so on Lite that is 3 months,
+    /// 89 to 92 days at <paramref name="utcNow"/>, rounded up to whole days.
+    /// </summary>
+    internal static TimeSpan AlertHistoryLongest(DateTime utcNow)
+    {
+        var kept = utcNow - utcNow.AddMonths(-RetentionService.ArchiveRetentionMonths);
+        var days = Math.Ceiling(kept.TotalDays);
+        return TimeSpan.FromDays(Math.Min(days, 365));
+    }
+
+    /// <summary>What to type for <see cref="AlertHistoryLongest"/>: "92d".</summary>
+    internal static string AlertHistoryLongestText(DateTime utcNow)
+        => ((int)AlertHistoryLongest(utcNow).TotalDays) + "d";
+
     /// <summary>True when <paramref name="range"/> carries its own instants rather than 'the last N hours'.</summary>
     internal static bool HasExplicitInstants(ResolvedTimeRange range) => range.Spec.WholeHours is not > 0;
 
diff --git a/Lite/Services/LocalDataService.AlertHistory.cs b/Lite/Services/LocalDataService.AlertHistory.cs
index 4532d8403b..0e5fa5f7e1 100644
--- a/Lite/Services/LocalDataService.AlertHistory.cs
+++ b/Lite/Services/LocalDataService.AlertHistory.cs
@@ -40,17 +40,34 @@ public partial class LocalDataService
     /// </summary>
     public async Task<List<AlertHistoryRow>> GetAlertHistoryAsync(int hoursBack = 24, int limit = 500, int? serverId = null, DateTime? asOfUtc = null, bool includeDismissed = false)
     {
-        using var connection = await OpenConnectionAsync();
-        using var command = connection.CreateCommand();
-
         /* Both edges, not just the lower one: the row cap is applied by the database, so trimming
            after the read would spend the whole LIMIT on rows newer than an as_of anchor and hand back an
            empty window that looks exactly like a quiet one. */
         var (cutoff, until) = GetTimeRange(hoursBack, null, null, asOfUtc);
+        return await ReadAlertHistoryAsync(cutoff, until, "<=", limit, serverId, includeDismissed);
+    }
+
+    /// <summary>
+    /// <see cref="GetAlertHistoryAsync"/> over a window that may END before now (#5562), the Alert History tab's read: the rows
+    /// from <paramref name="sinceUtc"/> up to but not including <paramref name="untilUtc"/>, which is <c>null</c> for a window
+    /// that runs to now. The end is applied in the SQL, ahead of the row cap, so a finished range is never shown the alerts
+    /// raised after its end and a busy fleet's cap is not spent on them. Dismissed alerts stay hidden. The Darling Viewer's
+    /// Alert History reads the same way (<c>GetAlertHistoryWindowAsync</c>).
+    /// </summary>
+    public Task<List<AlertHistoryRow>> GetAlertHistoryWindowAsync(DateTime sinceUtc, DateTime? untilUtc, int? serverId = null, int limit = 500)
+        => untilUtc is { } end
+            ? ReadAlertHistoryAsync(sinceUtc, end, "<", limit, serverId, includeDismissed: false)
+            : ReadAlertHistoryAsync(sinceUtc, DateTime.UtcNow, "<=", limit, serverId, includeDismissed: false);
+
+    private async Task<List<AlertHistoryRow>> ReadAlertHistoryAsync(
+        DateTime cutoff, DateTime until, string untilOperator, int limit, int? serverId, bool includeDismissed)
+    {
+        using var connection = await OpenConnectionAsync();
+        using var command = connection.CreateCommand();
 
         if (serverId.HasValue)
         {
-            command.CommandText = @"
+            command.CommandText = $@"
 SELECT
     alert_time,
     server_id,
@@ -68,7 +85,7 @@ empty window that looks exactly like a quiet one. */
     dismissed
 FROM v_config_alert_log
 WHERE alert_time >= $1
-AND   alert_time <= $2
+AND   alert_time {untilOperator} $2
 AND   server_id = $3
 AND   (dismissed = FALSE OR $5)
 ORDER BY alert_time DESC
@@ -81,7 +98,7 @@ ORDER BY alert_time DESC
         }
         else
         {
-            command.CommandText = @"
+            command.CommandText = $@"
 SELECT
     alert_time,
     server_id,
@@ -99,7 +116,7 @@ ORDER BY alert_time DESC
     dismissed
 FROM v_config_alert_log
 WHERE alert_time >= $1
-AND   alert_time <= $2
+AND   alert_time {untilOperator} $2
 AND   (dismissed = FALSE OR $4)
 ORDER BY alert_time DESC
 LIMIT $3";
@@ -321,52 +338,74 @@ SELECT 1 FROM dismissed_archive_alerts
     /// Updates the live table, then inserts any remaining archived alerts into the sidecar table.
     /// Logs structured telemetry and verifies dismissal success.
     /// </summary>
-    public async Task<int> DismissAllVisibleAlertsAsync(int hoursBack, int? serverId = null)
+    public Task<int> DismissAllVisibleAlertsAsync(int hoursBack, int? serverId = null)
+        => DismissAllVisibleAlertsWindowAsync(DateTime.UtcNow.AddHours(-hoursBack), null, serverId);
+
+    /// <summary>
+    /// <see cref="DismissAllVisibleAlertsAsync"/> over the window <see cref="GetAlertHistoryWindowAsync"/> shows (#5562): the
+    /// alerts from <paramref name="sinceUtc"/> up to but not including <paramref name="untilUtc"/> (<c>null</c> = to now), so a
+    /// finished range's Dismiss All touches exactly the rows its grid shows and none raised after its end. The Darling Viewer's
+    /// <c>DismissAllVisibleAlertsWindowAsync</c> scopes the same way.
+    /// </summary>
+    public async Task<int> DismissAllVisibleAlertsWindowAsync(DateTime sinceUtc, DateTime? untilUtc, int? serverId = null)
     {
         var sw = System.Diagnostics.Stopwatch.StartNew();
 
         if (App.LogAlertDismissals)
-            AppLogger.Info("AlertDismiss", $"Action=DismissAll, HoursBack={hoursBack}, ServerId={serverId?.ToString() ?? "all"}");
+            AppLogger.Info("AlertDismiss", $"Action=DismissAll, Since={sinceUtc:O}, Until={(untilUtc.HasValue ? untilUtc.Value.ToString("O") : "now")}, ServerId={serverId?.ToString() ?? "all"}");
 
         using var connection = await OpenWriteConnectionAsync();
         PreservedTableRestore.ThrowIfRestorePending(_duckDb.ArchivePath, "dismissed_archive_alerts");
         using var command = connection.CreateCommand();
 
-        var cutoff = DateTime.UtcNow.AddHours(-hoursBack);
+        var cutoff = sinceUtc;
+
+        /* The exclusive end is the last parameter of each statement ($3 with a server filter, $2 without). */
+        var endParam = serverId.HasValue ? "$3" : "$2";
+        var liveEnd = untilUtc.HasValue ? $"AND    alert_time < {endParam}" : string.Empty;
+        var viewEnd = untilUtc.HasValue ? $"AND    v.alert_time < {endParam}" : string.Empty;
 
         if (serverId.HasValue)
         {
-            command.CommandText = @"
+            command.CommandText = $@"
 UPDATE config_alert_log
 SET    dismissed = TRUE
 WHERE  alert_time >= $1
 AND    server_id = $2
+{liveEnd}
 AND    dismissed = FALSE";
             command.Parameters.Add(new DuckDBParameter { Value = cutoff });
             command.Parameters.Add(new DuckDBParameter { Value = serverId.Value });
         }
         else
         {
-            command.CommandText = @"
+            command.CommandText = $@"
 UPDATE config_alert_log
 SET    dismissed = TRUE
 WHERE  alert_time >= $1
+{liveEnd}
 AND    dismissed = FALSE";
             command.Parameters.Add(new DuckDBParameter { Value = cutoff });
         }
 
+        if (untilUtc.HasValue)
+        {
+            command.Parameters.Add(new DuckDBParameter { Value = untilUtc.Value });
+        }
+
         var liveAffected = await command.ExecuteNonQueryAsync();
 
         // Dismiss any remaining archived alerts that matched the filter
         using var sidecarCmd = connection.CreateCommand();
         if (serverId.HasValue)
         {
-            sidecarCmd.CommandText = @"
+            sidecarCmd.CommandText = $@"
 INSERT INTO dismissed_archive_alerts (alert_time, server_id, metric_name)
 SELECT v.alert_time, v.server_id, v.metric_name
 FROM   v_config_alert_log v
 WHERE  v.alert_time >= $1
 AND    v.server_id = $2
+{viewEnd}
 AND    v.dismissed = FALSE
 AND    NOT EXISTS (
     SELECT 1 FROM config_alert_log l
@@ -385,11 +424,12 @@ SELECT 1 FROM dismissed_archive_alerts d
         }
         else
         {
-            sidecarCmd.CommandText = @"
+            sidecarCmd.CommandText = $@"
 INSERT INTO dismissed_archive_alerts (alert_time, server_id, metric_name)
 SELECT v.alert_time, v.server_id, v.metric_name
 FROM   v_config_alert_log v
 WHERE  v.alert_time >= $1
+{viewEnd}
 AND    v.dismissed = FALSE
 AND    NOT EXISTS (
     SELECT 1 FROM config_alert_log l
@@ -406,6 +446,11 @@ SELECT 1 FROM dismissed_archive_alerts d
             sidecarCmd.Parameters.Add(new DuckDBParameter { Value = cutoff });
         }
 
+        if (untilUtc.HasValue)
+        {
+            sidecarCmd.Parameters.Add(new DuckDBParameter { Value = untilUtc.Value });
+        }
+
         var archivedAffected = await sidecarCmd.ExecuteNonQueryAsync();
         sw.Stop();
 
@@ -415,7 +460,7 @@ SELECT 1 FROM dismissed_archive_alerts d
         // Post-dismiss verification: confirm no undismissed live rows remain
         if (liveAffected > 0)
         {
-            await VerifyDismissAllAsync(connection, cutoff, serverId, liveAffected);
+            await VerifyDismissAllAsync(connection, cutoff, untilUtc, serverId, liveAffected);
         }
 
         return liveAffected + archivedAffected;
@@ -493,30 +538,38 @@ the restart restores is aged out again on its next run. */
     /// <summary>
     /// Verifies that no undismissed alerts remain in the dismissed time range.
     /// </summary>
-    private static async System.Threading.Tasks.Task VerifyDismissAllAsync(LockedConnection connection, DateTime cutoff, int? serverId, int expectedDismissed)
+    private static async System.Threading.Tasks.Task VerifyDismissAllAsync(LockedConnection connection, DateTime cutoff, DateTime? untilUtc, int? serverId, int expectedDismissed)
     {
         try
         {
             using var cmd = connection.CreateCommand();
+            var endClause = untilUtc.HasValue ? $"AND    alert_time < {(serverId.HasValue ? "$3" : "$2")}" : string.Empty;
             if (serverId.HasValue)
             {
-                cmd.CommandText = @"
+                cmd.CommandText = $@"
 SELECT COUNT(1) FROM config_alert_log
 WHERE  alert_time >= $1
 AND    server_id = $2
+{endClause}
 AND    dismissed = FALSE";
                 cmd.Parameters.Add(new DuckDBParameter { Value = cutoff });
                 cmd.Parameters.Add(new DuckDBParameter { Value = serverId.Value });
             }
             else
             {
-                cmd.CommandText = @"
+                cmd.CommandText = $@"
 SELECT COUNT(1) FROM config_alert_log
 WHERE  alert_time >= $1
+{endClause}
 AND    dismissed = FALSE";
                 cmd.Parameters.Add(new DuckDBParameter { Value = cutoff });
             }
 
+            if (untilUtc.HasValue)
+            {
+                cmd.Parameters.Add(new DuckDBParameter { Value = untilUtc.Value });
+            }
+
             var remaining = Convert.ToInt64(await cmd.ExecuteScalarAsync());
             if (remaining > 0)
                 AppLogger.Warn("AlertDismiss", $"Action=DismissAllVerify, Result=Mismatch, StillUndismissed={remaining}, ExpectedDismissed={expectedDismissed}");
diff --git a/Lite/Services/LocalDataService.JobHistory.cs b/Lite/Services/LocalDataService.JobHistory.cs
index 381516771a..e2b0bf0d6d 100644
--- a/Lite/Services/LocalDataService.JobHistory.cs
+++ b/Lite/Services/LocalDataService.JobHistory.cs
@@ -56,16 +56,18 @@ public Task<List<JobHistoryRow>> GetJobHistoryAsync(int hoursBack = 24, int limi
     /// on its open tab's clock when it has one, then the machine's, the chain the Alert History tab uses.
     /// </summary>
     public async Task<List<JobHistoryRow>> GetJobHistoryAsync(
-        DateTime windowStartUtc, int limit, int? serverId, IReadOnlyDictionary<int, ServerClock>? openTabClocks = null) =>
-        (await GetJobHistoryWithClocksAsync(windowStartUtc, limit, serverId, openTabClocks)).Rows;
+        DateTime windowStartUtc, int limit, int? serverId, IReadOnlyDictionary<int, ServerClock>? openTabClocks = null,
+        DateTime? windowEndUtc = null) =>
+        (await GetJobHistoryWithClocksAsync(windowStartUtc, limit, serverId, openTabClocks, windowEndUtc)).Rows;
 
     /// <summary>
-    /// <see cref="GetJobHistoryAsync(DateTime, int, int?, IReadOnlyDictionary{int, ServerClock}?)"/> that also returns the clock it
+    /// <see cref="GetJobHistoryAsync(DateTime, int, int?, IReadOnlyDictionary{int, ServerClock}?, DateTime?)"/> that also returns the clock it
     /// windowed each server on, by server id (#4966). The tab words the note for one server from <c>Clocks[serverId]</c>, so the note
     /// and the read share one clock read and cannot disagree on a clock that changed between two reads.
     /// </summary>
     internal async Task<(List<JobHistoryRow> Rows, IReadOnlyDictionary<int, ServerClock> Clocks)> GetJobHistoryWithClocksAsync(
-        DateTime windowStartUtc, int limit, int? serverId, IReadOnlyDictionary<int, ServerClock>? openTabClocks = null)
+        DateTime windowStartUtc, int limit, int? serverId, IReadOnlyDictionary<int, ServerClock>? openTabClocks = null,
+        DateTime? windowEndUtc = null)
     {
         var serverIds = serverId.HasValue
             ? new List<int> { serverId.Value }
@@ -77,10 +79,10 @@ public async Task<List<JobHistoryRow>> GetJobHistoryAsync(
         {
             var clock = await ReadJobHistoryClockAsync(id, openTabClocks is not null && openTabClocks.TryGetValue(id, out var tabClock) ? tabClock : null);
             clocks[id] = clock;
-            rows.AddRange(await ReadJobHistoryForServerAsync(id, clock, windowStartUtc, limit));
+            rows.AddRange(await ReadJobHistoryForServerAsync(id, clock, windowStartUtc, limit, windowEndUtc));
         }
 
-        return (ApplyJobHistoryWindow(rows, windowStartUtc, limit), clocks);
+        return (ApplyJobHistoryWindow(rows, windowStartUtc, limit, windowEndUtc), clocks);
     }
 
     /// <summary>This machine's zone, the last clock in the Job History chain. A seam for the tests, which name a fixed zone so a
@@ -223,12 +225,14 @@ private async Task<List<int>> ReadJobHistoryViewerServerIdsAsync(DateTime startU
     /// <paramref name="windowStartUtc"/> (each server's SQL pre-filter is widened by an hour, so a run just before the
     /// window can still be in the set), orders them newest first by their real instant (two servers' stored wall clocks
     /// are in different zones, so the raw order is not the order the runs happened in), and keeps the newest
-    /// <paramref name="limit"/>. The server id is the last tie-break so the order is the same on every read.
+    /// <paramref name="limit"/>. The server id is the last tie-break so the order is the same on every read. A
+    /// <paramref name="windowEndUtc"/> (#5562) is exclusive and is applied in the SQL before each server's row cap
+    /// (<see cref="ReadJobHistoryForServerAsync"/>); the check here is the exact one after the server-local to UTC conversion.
     /// </summary>
-    internal static List<JobHistoryRow> ApplyJobHistoryWindow(List<JobHistoryRow> rows, DateTime windowStartUtc, int limit)
+    internal static List<JobHistoryRow> ApplyJobHistoryWindow(List<JobHistoryRow> rows, DateTime windowStartUtc, int limit, DateTime? windowEndUtc = null)
     {
         return rows
-            .Where(r => r.RunDateTimeUtc is { } runUtc && runUtc >= windowStartUtc)
+            .Where(r => r.RunDateTimeUtc is { } runUtc && runUtc >= windowStartUtc && (windowEndUtc is not { } end || runUtc < end))
             .OrderByDescending(r => r.RunDateTimeUtc)
             .ThenByDescending(r => r.InstanceId)
             .ThenByDescending(r => r.ServerId)
@@ -238,7 +242,23 @@ internal static List<JobHistoryRow> ApplyJobHistoryWindow(List<JobHistoryRow> ro
 
     /// <summary>One server's runs: the newest <paramref name="limit"/> at or after the server-local start of the window,
     /// each with its run time converted to UTC through <paramref name="clock"/>. Not yet held to the exact window.</summary>
-    private async Task<List<JobHistoryRow>> ReadJobHistoryForServerAsync(int serverId, ServerClock clock, DateTime windowStartUtc, int limit)
+    private async Task<List<JobHistoryRow>> ReadJobHistoryForServerAsync(int serverId, ServerClock clock, DateTime windowStartUtc, int limit, DateTime? windowEndUtc)
+    {
+        var items = await ReadJobHistoryForServerOnceAsync(serverId, clock, windowStartUtc, limit, windowEndUtc);
+        if (windowEndUtc is not { } end || limit <= 0 || items.Count < limit)
+        {
+            return items;
+        }
+
+        /* #5562: the SQL end bound is the server-local end widened by an hour (a daylight-saving change next to the end
+           moves the stored wall clock by an hour against the instant), so a run in that margin can sit among the newest
+           rows and displace a run inside the window from the cap. The margin rows are the newest ones, so they are all in
+           the first read: count them and read again with that many more rows, and the cap lands on the window. */
+        var outside = items.Count(r => r.RunDateTimeUtc is { } runUtc && runUtc >= end);
+        return outside == 0 ? items : await ReadJobHistoryForServerOnceAsync(serverId, clock, windowStartUtc, limit + outside, windowEndUtc);
+    }
+
+    private async Task<List<JobHistoryRow>> ReadJobHistoryForServerOnceAsync(int serverId, ServerClock clock, DateTime windowStartUtc, int limit, DateTime? windowEndUtc)
     {
         using var connection = await OpenConnectionAsync();
         using var command = connection.CreateCommand();
@@ -249,6 +269,11 @@ private async Task<List<JobHistoryRow>> ReadJobHistoryForServerAsync(int serverI
         var statsStart = clock.ToServerLocal(windowStartUtc);
         var preFilterStart = statsStart.AddHours(-1);
 
+        /* #5562 (R6): a window that ended before now has a real END bound, in the SQL and ahead of the row cap, so the cap
+           counts the runs inside the window, not the newer ones after it. The bound is exclusive, on the server-local wall
+           clock, widened an hour like the start; the exact instant check and the margin re-read are ReadJobHistoryForServerAsync's. */
+        var endClause = windowEndUtc.HasValue ? "AND   run_datetime < $5" : string.Empty;
+
         /* #4229 (Darling parity): the per-job average/max used to run as a window function OVER every step
            row the window matched, forcing a full sort/aggregate of the whole set before ORDER BY/LIMIT could
            trim it. job_stats computes it once per (server_id, job_id) with a GROUP BY over just the step_id-0
@@ -267,6 +292,7 @@ FROM v_job_history
     WHERE step_id = 0
     AND   run_status = 1
     AND   run_datetime >= $3
+    {endClause}
     AND   server_id = $2
     GROUP BY server_id, job_id
 ),
@@ -290,6 +316,7 @@ base AS (
         message
     FROM v_job_history
     WHERE run_datetime >= $1
+    {endClause}
     AND   server_id = $2
     ORDER BY run_datetime DESC, instance_id DESC
     LIMIT $4
@@ -331,6 +358,10 @@ LEFT JOIN job_stats
         command.Parameters.Add(new DuckDBParameter { Value = serverId });
         command.Parameters.Add(new DuckDBParameter { Value = statsStart });
         command.Parameters.Add(new DuckDBParameter { Value = limit });
+        if (windowEndUtc.HasValue)
+        {
+            command.Parameters.Add(new DuckDBParameter { Value = clock.ToServerLocal(windowEndUtc.Value).AddHours(1) });
+        }
 
         var items = new List<JobHistoryRow>();
         using var reader = await command.ExecuteReaderAsync();

From c2ceca27f63511d825a0c1454cd4b9c0c5b9d0af Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:11:27 -0400
Subject: [PATCH 15/33] Lite: the sample note names the main collector of the
 sub-tab on screen (#5562)

---
 Lite/Controls/ServerTab.TimeRange.cs | 71 +++++++++++++++++++++++----
 Lite/Helpers/LiteTimeRange.cs        | 73 ++++++++++++++++++++++++++++
 Lite/MainWindow.xaml.cs              | 11 ++---
 3 files changed, 139 insertions(+), 16 deletions(-)

diff --git a/Lite/Controls/ServerTab.TimeRange.cs b/Lite/Controls/ServerTab.TimeRange.cs
index bf7ec6c258..51f37945c4 100644
--- a/Lite/Controls/ServerTab.TimeRange.cs
+++ b/Lite/Controls/ServerTab.TimeRange.cs
@@ -62,26 +62,77 @@ private ResolvedTimeRange CurrentRange()
     private ResolvedTimeRange? _lastResolvedRange;
 
     /// <summary>
-    /// How often this tab's main collector samples, read from the schedule when asked (#5562, ruling R3): the picker shows
-    /// 'Data here is collected every N minutes.' when a span holds fewer than 3 samples. Set by MainWindow, which owns the
-    /// schedule; a tab opened without one (a test) shows no note.
+    /// How often the main collector of the page on screen samples, read from the schedule when asked (#5562, ruling R3): the
+    /// picker shows 'Data here is collected every N minutes.' when a span holds fewer than 3 samples. The argument is the
+    /// collector's name (<see cref="CurrentMainCollector"/>) and the answer its ACTUAL interval on this server. Set by
+    /// MainWindow, which owns the schedule; a tab opened without one (a test) shows no note.
     /// </summary>
-    private Func<TimeSpan?>? _sampleIntervalProvider;
+    private Func<string, TimeSpan?>? _sampleIntervalProvider;
+    private bool _sampleNoteWired;
 
-    /// <summary>The collector whose cadence the picker's note names: the 1-minute wait stats sample behind the tab's charts.</summary>
-    internal const string MainCollectorName = "wait_stats";
-
-    /// <summary>Hands the tab the way to read its main collector's actual interval (<see cref="MainCollectorName"/>).</summary>
-    public void SetSampleIntervalSource(Func<TimeSpan?> provider)
+    /// <summary>Hands the tab the way to read a collector's actual interval on this server.</summary>
+    public void SetSampleIntervalSource(Func<string, TimeSpan?> provider)
     {
         _sampleIntervalProvider = provider;
+        if (!_sampleNoteWired)
+        {
+            _sampleNoteWired = true;
+
+            /* A tab or sub-tab change moves the page on screen, so the note names that page's collector. */
+            AddHandler(System.Windows.Controls.Primitives.Selector.SelectionChangedEvent, new SelectionChangedEventHandler((_, e) =>
+            {
+                if (e.OriginalSource is TabControl)
+                {
+                    RefreshRangeNotes();
+                }
+            }));
+        }
+
         RefreshRangeNotes();
     }
 
+    /// <summary>
+    /// The main collector of the sub-tab on screen (<see cref="LiteTimeRange.MainCollectorFor"/>): the top tab's header and,
+    /// when that tab holds a sub-tab control, the selected sub-tab's. Never widens the range; <c>null</c> shows no note.
+    /// </summary>
+    internal string? CurrentMainCollector()
+    {
+        if (MainTabControl.SelectedItem is not TabItem top)
+        {
+            return null;
+        }
+
+        string? sub = null;
+        if (top.Content is DependencyObject content && FindFirstTabControl(content) is { SelectedItem: TabItem selected })
+        {
+            sub = selected.Header as string;
+        }
+
+        return LiteTimeRange.MainCollectorFor(top.Header as string, sub);
+    }
+
+    private static TabControl? FindFirstTabControl(DependencyObject parent)
+    {
+        foreach (var child in LogicalTreeHelper.GetChildren(parent))
+        {
+            if (child is TabControl tabs)
+            {
+                return tabs;
+            }
+
+            if (child is DependencyObject next && FindFirstTabControl(next) is { } found)
+            {
+                return found;
+            }
+        }
+
+        return null;
+    }
+
     /// <summary>Redraws the picker's resolved text and its sample-interval note (a live range slides; the schedule can be edited).</summary>
     private void RefreshRangeNotes()
     {
-        RangePicker.SampleInterval = _sampleIntervalProvider?.Invoke();
+        RangePicker.SampleInterval = CurrentMainCollector() is { } collector ? _sampleIntervalProvider?.Invoke(collector) : null;
         RangePicker.Refresh();
     }
 
diff --git a/Lite/Helpers/LiteTimeRange.cs b/Lite/Helpers/LiteTimeRange.cs
index c776d88605..d432c087cd 100644
--- a/Lite/Helpers/LiteTimeRange.cs
+++ b/Lite/Helpers/LiteTimeRange.cs
@@ -7,8 +7,10 @@
  */
 
 using System;
+using PerformanceMonitor.Collectors;
 using PerformanceMonitor.Ui;
 using PerformanceMonitorLite.Services;
+using PerformanceMonitorLite.Models;
 
 namespace PerformanceMonitorLite.Helpers;
 
@@ -173,6 +175,77 @@ internal static (string? rangeId, int? hours) SettingsFor(TimeRangeSpec spec)
     internal static DateTime DataStartFor(DateTime? probedFloorUtc, DateTime utcNow) =>
         probedFloorUtc ?? RetentionService.OldestRetainedInstant(utcNow);
 
+    /// <summary>
+    /// The collector behind the data a server-tab page shows (#5562 R3): the page's MAIN collector, by the header of the top
+    /// tab and of the sub-tab on screen. <c>null</c> for a page with no single sampled source (Overview, Plan Viewer, the
+    /// on-load configuration pages, Daily Summary, Collection Health), where the picker shows no sample note.
+    /// </summary>
+    internal static string? MainCollectorFor(string? tab, string? subTab) => tab switch
+    {
+        "Wait Stats" => "wait_stats",
+        "Queries" => subTab switch
+        {
+            "Performance Trends" => "query_stats",
+            "Active Queries" => "query_snapshots",
+            "Top Queries by Duration" => "query_stats",
+            "Top Procedures by Duration" => "procedure_stats",
+            "Query Store by Duration" => "query_store",
+            "Plan Corrections" => "plan_correction",
+            "Query Heatmap" => "query_stats",
+            _ => null
+        },
+        "CPU" => "cpu_utilization",
+        "Memory" => subTab switch
+        {
+            "Overview" => "memory_stats",
+            "Memory Clerks" => "memory_clerks",
+            "Memory Grants" => "memory_grant_stats",
+            "Memory Pressure Events" => "memory_pressure_events",
+            _ => null
+        },
+        "File I/O" => "file_io_stats",
+        "tempdb" => "tempdb_stats",
+        "Blocking" => subTab switch
+        {
+            "Trends" => "dmv_blocking_snapshot",
+            "Current Waits" => "waiting_tasks",
+            "Blocked Process Reports" => "blocked_process_report",
+            "Deadlocks" => "deadlocks",
+            "Blocking Stats" => "dmv_blocking_snapshot",
+            _ => null
+        },
+        "Perfmon" => "perfmon_stats",
+        "Running Jobs" => "running_jobs",
+        "Latches & Spinlocks" => "latch_stats",
+        "CPU Scheduler" => "cpu_scheduler_stats",
+        "Plan Cache" => "plan_cache_stats",
+        "Session Stats" => "session_stats",
+        "System Events" => subTab == "Default Trace" ? "default_trace_events" : "system_health_events",
+        _ => null
+    };
+
+    /// <summary>
+    /// A collector's actual cadence for the sample note: its schedule on this server when it has one (a disabled collector
+    /// samples nothing, so no note), else the shipped default (<see cref="CollectorScheduleDefaults"/>). <c>null</c> for no
+    /// collector, an on-load one, or one that ships off and was never scheduled.
+    /// </summary>
+    internal static TimeSpan? SampleIntervalForCollector(string? collector, CollectorSchedule? schedule)
+    {
+        if (collector is null)
+        {
+            return null;
+        }
+
+        if (schedule is not null)
+        {
+            return schedule.Enabled ? SampleIntervalFor(schedule.FrequencyMinutes) : null;
+        }
+
+        return CollectorScheduleDefaults.All.TryGetValue(collector, out var entry) && entry.DefaultEnabled
+            ? SampleIntervalFor(entry.FrequencyMinutes)
+            : null;
+    }
+
     /// <summary>A collector's actual cadence as the picker's sample interval; null for a collector that does not run on a schedule (0 = on load).</summary>
     internal static TimeSpan? SampleIntervalFor(int? frequencyMinutes) =>
         frequencyMinutes is > 0 ? TimeSpan.FromMinutes(frequencyMinutes.Value) : null;
diff --git a/Lite/MainWindow.xaml.cs b/Lite/MainWindow.xaml.cs
index 0666115e48..345f62b72f 100644
--- a/Lite/MainWindow.xaml.cs
+++ b/Lite/MainWindow.xaml.cs
@@ -1220,12 +1220,11 @@ registration there would wait out the reset's drain timeout. */
 
         serverTab.AlertCountsChanged += alertHandler;
         serverTab.ApplyTimeRangeRequested += timeRangeHandler;
-        /* #5562: the picker's 'collected every N minutes' note names this server's ACTUAL cadence for the tab's main
-           collector, read from the schedule each time (it can be edited while the tab is open). */
-        serverTab.SetSampleIntervalSource(() => PerformanceMonitorLite.Helpers.LiteTimeRange.SampleIntervalFor(
-            _scheduleManager.GetScheduleForServer(server.Id, ServerTab.MainCollectorName) is { Enabled: true } schedule
-                ? schedule.FrequencyMinutes
-                : null));
+        /* #5562: the picker's 'collected every N minutes' note names this server's ACTUAL cadence for the main collector of the
+           page on screen (ServerTab.CurrentMainCollector), read from the schedule each time (it can be edited while the tab is
+           open) and falling back to the shipped default when the schedule has no entry for it. */
+        serverTab.SetSampleIntervalSource(collector => PerformanceMonitorLite.Helpers.LiteTimeRange.SampleIntervalForCollector(
+            collector, _scheduleManager.GetScheduleForServer(server.Id, collector)));
         serverTab.ManualRefreshRequested += refreshHandler;
         /* #1319: persist the per-server view database filter (no credential side effects). The handler
            captures only the long-lived _serverManager, so it needs no explicit unsubscribe. */

From 17f08de7adf5269e408fda98de8d3f57b977aefe Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:15:35 -0400
Subject: [PATCH 16/33] Lite: every banner site feeds the picker's data start
 (#5562)

---
 .../CorrelatedTimelineLanesControl.xaml.cs    |  6 +++-
 Lite/Controls/JobHistoryTab.xaml.cs           |  7 +++--
 Lite/Controls/LiteBlockingLaneDataStart.cs    |  4 ++-
 .../ServerTab.BlockingChartsDataStart.cs      |  2 ++
 Lite/Controls/ServerTab.Refresh.cs            |  9 ++----
 Lite/Controls/ServerTab.TimeRange.cs          | 31 +++++++++++++++++++
 Lite/Controls/ServerTab.xaml.cs               |  1 +
 Lite/Helpers/LiteTimeRange.cs                 | 25 +++++++++++++--
 8 files changed, 73 insertions(+), 12 deletions(-)

diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index ab6e13e2a6..bd3b7a963f 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -374,6 +374,9 @@ await ShowBlockingLaneDataStartAsync(
     /// 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>
+    /// <summary>Raised with the data start the blocking lane's note chose (#5562 R7), so the tab's picker can name it. Null when the note found none.</summary>
+    internal event Action<DateTime?>? DataStartFound;
+
     private async Task ShowBlockingLaneDataStartAsync(
         DateTime startUtc, DateTime endUtc, IReadOnlyList<TrendPoint> blockingBars, IReadOnlyList<TrendPoint> deadlockBars)
     {
@@ -388,7 +391,8 @@ await LiteBlockingLaneDataStart.ShowAsync(
             {
                 var (on, first, zero) = await _dataService!.GetBlockedProcessThresholdOnAsync(_serverId, startUtc, endUtc);
                 return new LiteBlockingLaneDataStart.BlockedProcessThreshold(on, first, zero);
-            }));
+            }),
+            onStartChosen: start => DataStartFound?.Invoke(start));
     }
 
     private void UpdateBlockingLane(List<(double Time, double Value)> blockingData,
diff --git a/Lite/Controls/JobHistoryTab.xaml.cs b/Lite/Controls/JobHistoryTab.xaml.cs
index 7761b26cf7..1db7f1fb8e 100644
--- a/Lite/Controls/JobHistoryTab.xaml.cs
+++ b/Lite/Controls/JobHistoryTab.xaml.cs
@@ -196,7 +196,8 @@ await ShowJobHistoryDataStartAsync(
             JobHistoryWindowTruncatedBanner,
             () => System.Threading.Tasks.Task.Run(() => service.GetJobHistoryDataStartAsync(serverId, startUtc, endUtc)),
             startUtc, endUtc, read, zone, inUtc: serverId is null,
-            superseded: () => _loads.Superseded(nameof(LoadJobsAsync), gen));
+            superseded: () => _loads.Superseded(nameof(LoadJobsAsync), gen),
+            onFloor: floor => RangePicker.DataStartUtc = LiteTimeRange.DataStartFor(floor, DateTime.UtcNow));
     }
 
     /// <summary>
@@ -222,7 +223,8 @@ await ShowJobHistoryDataStartAsync(
     /// <param name="superseded">True when a newer load has started: checked after the probe answers and before the banner is written.</param>
     internal static System.Threading.Tasks.Task ShowJobHistoryDataStartAsync(
         TextBlock banner, Func<System.Threading.Tasks.Task<DateTime?>> probe, DateTime startUtc, DateTime endUtc,
-        IReadOnlyCollection<JobHistoryRow> read, TimeZoneInfo zone, bool inUtc, Func<bool>? superseded = null)
+        IReadOnlyCollection<JobHistoryRow> read, TimeZoneInfo zone, bool inUtc, Func<bool>? superseded = null,
+        Action<DateTime?>? onFloor = null)
     {
         var runTimes = read.Where(r => r.RunDateTimeUtc.HasValue).Select(r => r.RunDateTimeUtc!.Value).ToList();
 
@@ -246,6 +248,7 @@ void Word()
                 if (superseded?.Invoke() == true) return;
 
                 ServerTab.ApplyWindowFloorToBanner(banner, ServerTab.EarlierOfFloorAndRowShown(floor, ServerTab.EarliestRowShown(runTimes, t => t)), startUtc, zone);
+                onFloor?.Invoke(floor); /* #5562 R7: the picker's data-start note takes the floor this probe found */
                 Word();
             });
     }
diff --git a/Lite/Controls/LiteBlockingLaneDataStart.cs b/Lite/Controls/LiteBlockingLaneDataStart.cs
index f589f8700d..ff81a142d8 100644
--- a/Lite/Controls/LiteBlockingLaneDataStart.cs
+++ b/Lite/Controls/LiteBlockingLaneDataStart.cs
@@ -64,10 +64,12 @@ internal static async Task ShowAsync(
         TextBlock banner, Func<QueryWindowRelation, Task<DateTime?>> floorOf, DateTime startUtc, DateTime endUtc,
         IEnumerable<TrendPoint> blockingBars, IEnumerable<TrendPoint> deadlockBars, TimeZoneInfo zone,
         Func<Task<bool>>? blockingReadTookXe = null, Func<Task<DateTime?>>? xeOnlyBlockingFloorOf = null,
-        Func<Task<DateTime?>>? earliestReportOf = null, Func<Task<BlockedProcessThreshold>>? thresholdOf = null)
+        Func<Task<DateTime?>>? earliestReportOf = null, Func<Task<BlockedProcessThreshold>>? thresholdOf = null,
+        Action<DateTime?>? onStartChosen = null)
     {
         var start = await StartAsync(floorOf, startUtc, endUtc, blockingBars, deadlockBars, blockingReadTookXe, xeOnlyBlockingFloorOf, earliestReportOf, thresholdOf);
         ServerTab.ApplyWindowFloorToBanner(banner, start, startUtc, zone);
+        onStartChosen?.Invoke(start); /* #5562 R7: the picker's data-start note takes the start this banner chose */
     }
 
     /// <summary>
diff --git a/Lite/Controls/ServerTab.BlockingChartsDataStart.cs b/Lite/Controls/ServerTab.BlockingChartsDataStart.cs
index 2635b7b7d3..c894557a0c 100644
--- a/Lite/Controls/ServerTab.BlockingChartsDataStart.cs
+++ b/Lite/Controls/ServerTab.BlockingChartsDataStart.cs
@@ -11,6 +11,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using System.Windows.Controls;
+using PerformanceMonitorLite.Helpers;
 using PerformanceMonitorLite.Mcp;
 using PerformanceMonitorLite.Services;
 
@@ -81,6 +82,7 @@ private async System.Threading.Tasks.Task RefreshBlockingBannerAsync(
             () => Task.Run(() => _dataService.GetBlockingXeDataStartAsync(_serverId, start, end, databaseNames)),
             $"[{_server.DisplayName}] {QueryWindowRelation.BlockedProcessReports}", start, end);
         ApplyWindowFloorToBanner(banner, EarlierOfFloorAndRowShown(floor, earliestDrawn), start, GetPickerZone());
+        FeedDataStart(LiteTimeRange.CollectorOfRelation(QueryWindowRelation.BlockedProcessReports), floor); /* #5562 R7 */
     }
 
     /// <summary>The Trends sub-tab's three notes, over the SAME UTC window the three reads took.</summary>
diff --git a/Lite/Controls/ServerTab.Refresh.cs b/Lite/Controls/ServerTab.Refresh.cs
index 00e77fe2f2..7dc3dabaf7 100644
--- a/Lite/Controls/ServerTab.Refresh.cs
+++ b/Lite/Controls/ServerTab.Refresh.cs
@@ -612,12 +612,9 @@ private async System.Threading.Tasks.Task RefreshWindowTruncatedBannerAsync(Quer
             $"[{_server.DisplayName}] {relation}", startUtc, endUtc, ct);
         ApplyWindowFloorToBanner(banner, EarlierOfFloorAndRowShown(floor, earliestRowShownUtc), startUtc, GetPickerZone());
 
-        /* #5562: the picker's 'Data starts ...' note takes its start from the probe this tab already awaited (the Queries
-           grid's, the primary surface), else the archive's static retention edge. No new query. */
-        if (relation == QueryWindowRelation.QueryStats)
-        {
-            RangePicker.DataStartUtc = LiteTimeRange.DataStartFor(floor, DateTime.UtcNow);
-        }
+        /* #5562 R7: the picker's 'Data starts ...' note takes its start from the probe this site already awaited, for the page
+           on screen (every relation, not only the Queries grid's), else the archive's static retention edge. No new query. */
+        FeedDataStart(LiteTimeRange.CollectorOfRelation(relation), floor);
     }
 
     /// <summary>
diff --git a/Lite/Controls/ServerTab.TimeRange.cs b/Lite/Controls/ServerTab.TimeRange.cs
index 51f37945c4..696b07af45 100644
--- a/Lite/Controls/ServerTab.TimeRange.cs
+++ b/Lite/Controls/ServerTab.TimeRange.cs
@@ -129,9 +129,40 @@ public void SetSampleIntervalSource(Func<string, TimeSpan?> provider)
         return null;
     }
 
+    /// <summary>
+    /// The floors the tab's banner probes found (#5562 R7), by the page that asked: a collector name, or "overview" for the
+    /// lanes on the Overview page. The picker names the floor of the page on screen; a page that has not probed yet, or a page
+    /// with no probe, gets the archive's static retention edge. No query of its own: every value is one a banner site
+    /// already awaited.
+    /// </summary>
+    private readonly Dictionary<string, DateTime?> _probedFloors = new();
+
+    /// <summary>
+    /// Hands the picker the data start a banner site found (every <c>ApplyWindowFloorToBanner</c> site calls this with its
+    /// surface's main collector, so a source-scan test can pin the sites). It shows only while that page is on screen.
+    /// </summary>
+    internal void FeedDataStart(string? collector, DateTime? floor)
+    {
+        if (collector is not null)
+        {
+            _probedFloors[collector] = floor;
+        }
+
+        ApplyDataStart();
+    }
+
+    /// <summary>Points the picker's data start at the page on screen: its probed floor, else the static retention edge.</summary>
+    private void ApplyDataStart()
+    {
+        var key = MainTabControl.SelectedItem is TabItem { Header: "Overview" } ? "overview" : CurrentMainCollector();
+        RangePicker.DataStartUtc = LiteTimeRange.DataStartFor(
+            key is not null && _probedFloors.TryGetValue(key, out var floor) ? floor : null, DateTime.UtcNow);
+    }
+
     /// <summary>Redraws the picker's resolved text and its sample-interval note (a live range slides; the schedule can be edited).</summary>
     private void RefreshRangeNotes()
     {
+        ApplyDataStart();
         RangePicker.SampleInterval = CurrentMainCollector() is { } collector ? _sampleIntervalProvider?.Invoke(collector) : null;
         RangePicker.Refresh();
     }
diff --git a/Lite/Controls/ServerTab.xaml.cs b/Lite/Controls/ServerTab.xaml.cs
index 2232aaf577..71fa6d4e87 100644
--- a/Lite/Controls/ServerTab.xaml.cs
+++ b/Lite/Controls/ServerTab.xaml.cs
@@ -299,6 +299,7 @@ refresh once when it becomes visible again so it isn't showing stale data on ret
 
         /* Chart hover tooltips */
         CorrelatedLanes.Initialize(_dataService, _serverId, GetPickerZone);
+        CorrelatedLanes.DataStartFound += start => FeedDataStart("overview", start); /* #5562 R7: the Overview lanes' blocking note */
         /* #4766: the six slicers word their time axis and range caption in the tab's display zone. */
         foreach (var slicer in new[] { ActiveQueriesSlicer, QueryStatsSlicer, ProcStatsSlicer, QueryStoreSlicer, BlockingSlicer, DeadlockSlicer })
             slicer.DisplayZone = GetPickerZone;
diff --git a/Lite/Helpers/LiteTimeRange.cs b/Lite/Helpers/LiteTimeRange.cs
index d432c087cd..fa28358080 100644
--- a/Lite/Helpers/LiteTimeRange.cs
+++ b/Lite/Helpers/LiteTimeRange.cs
@@ -207,11 +207,11 @@ internal static DateTime DataStartFor(DateTime? probedFloorUtc, DateTime utcNow)
         "tempdb" => "tempdb_stats",
         "Blocking" => subTab switch
         {
-            "Trends" => "dmv_blocking_snapshot",
+            "Trends" => "blocked_process_report",
             "Current Waits" => "waiting_tasks",
             "Blocked Process Reports" => "blocked_process_report",
             "Deadlocks" => "deadlocks",
-            "Blocking Stats" => "dmv_blocking_snapshot",
+            "Blocking Stats" => "deadlocks",
             _ => null
         },
         "Perfmon" => "perfmon_stats",
@@ -224,6 +224,27 @@ internal static DateTime DataStartFor(DateTime? probedFloorUtc, DateTime utcNow)
         _ => null
     };
 
+    /// <summary>The collector a floor probe's relation measures (#5562 R7), the key a banner site feeds the picker's data start under; null for a relation with no scheduled collector.</summary>
+    internal static string? CollectorOfRelation(QueryWindowRelation relation) => relation switch
+    {
+        QueryWindowRelation.QueryStats => "query_stats",
+        QueryWindowRelation.ProcedureStats => "procedure_stats",
+        QueryWindowRelation.QueryStoreStats => "query_store",
+        QueryWindowRelation.PlanCorrection => "plan_correction",
+        QueryWindowRelation.BlockedProcessReports => "blocked_process_report",
+        QueryWindowRelation.Deadlocks => "deadlocks",
+        QueryWindowRelation.DmvBlockingSnapshots => "dmv_blocking_snapshot",
+        QueryWindowRelation.QuerySnapshots => "query_snapshots",
+        QueryWindowRelation.SystemHealthEvents => "system_health_events",
+        QueryWindowRelation.DefaultTraceEvents => "default_trace_events",
+        QueryWindowRelation.LongQueryCompletions => "long_query_completions",
+        QueryWindowRelation.WaitingTasks => "waiting_tasks",
+        QueryWindowRelation.MemoryPressureEvents => "memory_pressure_events",
+        QueryWindowRelation.JobHistory => "job_history",
+        QueryWindowRelation.WaitStats => "wait_stats",
+        _ => null
+    };
+
     /// <summary>
     /// A collector's actual cadence for the sample note: its schedule on this server when it has one (a disabled collector
     /// samples nothing, so no note), else the shipped default (<see cref="CollectorScheduleDefaults"/>). <c>null</c> for no

From 9860b2bb1b882d9d9ddab9507fc0dd8e279216c9 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:30:15 -0400
Subject: [PATCH 17/33] Lite: tests for the FinOps, Job History, Alert History,
 sample note and data start gaps (#5562)

---
 Lite.Tests/JobHistoryDataStartTests.cs       |   8 +-
 Lite.Tests/LiteTimeRangeGapTests.cs          | 374 +++++++++++++++++++
 Lite.Tests/ServerTabHeldRangeTests.cs        |   3 +-
 Lite/Services/LocalDataService.JobHistory.cs |  27 +-
 4 files changed, 400 insertions(+), 12 deletions(-)
 create mode 100644 Lite.Tests/LiteTimeRangeGapTests.cs

diff --git a/Lite.Tests/JobHistoryDataStartTests.cs b/Lite.Tests/JobHistoryDataStartTests.cs
index 9f928f5e51..0026e17f65 100644
--- a/Lite.Tests/JobHistoryDataStartTests.cs
+++ b/Lite.Tests/JobHistoryDataStartTests.cs
@@ -217,7 +217,7 @@ public void TheCap_IsThe2000TheReadTakes_AndTheNoteStepGetsTheSameConstant()
         Assert.Equal(2000, JobHistoryTab.RowCap);
 
         var tab = StripComments(File.ReadAllText(RepoFile("Lite", "Controls", "JobHistoryTab.xaml.cs")).Replace("\r\n", "\n"));
-        Assert.Single(Regex.Matches(tab, @"GetJobHistoryWithClocksAsync\(startUtc, RowCap, serverId, openTabClocks\)"));
+        Assert.Single(Regex.Matches(tab, @"GetJobHistoryWithClocksAsync\(startUtc, RowCap, serverId, openTabClocks, rangeEndUtc\)"));
         Assert.Single(Regex.Matches(tab, @"ServerTab\.CappedGridBannerAsync\(runTimes, RowCap,"));
     }
 
@@ -560,10 +560,10 @@ public void TheTab_WorksOutTheWindowsStartOnce_AndHandsItToTheReadAndTheProbe()
         var load = LoadJobsBody(tab);
 
         Assert.Single(Regex.Matches(load, @"var nowUtc = DateTime\.UtcNow;"));
-        Assert.Single(Regex.Matches(load, @"var startUtc = nowUtc\.AddHours\(-hoursBack\);"));
+        Assert.Single(Regex.Matches(load, @"var \(startUtc, rangeEndUtc\) = LiteTimeRange\.BoundsOf\(RangePicker, 24, nowUtc\);"));
         Assert.Empty(Regex.Matches(load, @"DateTime\.UtcNow\.AddHours"));
-        Assert.Single(Regex.Matches(load, @"_dataService\.GetJobHistoryWithClocksAsync\(startUtc,\s*RowCap,\s*serverId,\s*openTabClocks\)"));
-        Assert.Single(Regex.Matches(load, @"ShowDataStartNoteAsync\(serverId,\s*readClocks,\s*startUtc,\s*nowUtc,\s*all,\s*gen\)"));
+        Assert.Single(Regex.Matches(load, @"_dataService\.GetJobHistoryWithClocksAsync\(startUtc,\s*RowCap,\s*serverId,\s*openTabClocks,\s*rangeEndUtc\)"));
+        Assert.Single(Regex.Matches(load, @"ShowDataStartNoteAsync\(serverId,\s*readClocks,\s*startUtc,\s*rangeEndUtc \?\? nowUtc,\s*all,\s*gen\)"));
         Assert.Single(Regex.Matches(tab, @"service\.GetJobHistoryDataStartAsync\(serverId,\s*startUtc,\s*endUtc\)"));
         Assert.Single(Regex.Matches(tab, @"var openTabClocks = _openTabClocks\?\.Invoke\(\);"));
     }
diff --git a/Lite.Tests/LiteTimeRangeGapTests.cs b/Lite.Tests/LiteTimeRangeGapTests.cs
new file mode 100644
index 0000000000..753ffed30b
--- /dev/null
+++ b/Lite.Tests/LiteTimeRangeGapTests.cs
@@ -0,0 +1,374 @@
+/*
+ * 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.Linq;
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using DuckDB.NET.Data;
+using PerformanceMonitor.Collectors;
+using PerformanceMonitor.Ui;
+using PerformanceMonitorLite.Database;
+using PerformanceMonitorLite.Helpers;
+using PerformanceMonitorLite.Models;
+using PerformanceMonitorLite.Services;
+using Xunit;
+
+namespace PerformanceMonitorLite.Tests;
+
+/// <summary>
+/// #5562 gaps the first Lite pass left: FinOps pickers are rolling only (R5), Job History and Alert History read a real END
+/// bound ahead of their row caps (R6), Alert History's longest choice is the alert log's retention (R8), the sample note
+/// names the main collector of the sub-tab on screen (R3), and every banner site feeds the picker's data start (R7).
+/// </summary>
+public sealed class LiteTimeRangeGapTests : IClassFixture<SharedDuckDbFixture>, IDisposable
+{
+    private readonly DuckDbInitializer _duckDb;
+    private DuckDBConnection? _seedConn;
+    private long _nextId = 9000;
+
+    public LiteTimeRangeGapTests(SharedDuckDbFixture fixture)
+    {
+        fixture.ResetData();
+        _duckDb = fixture.DuckDb;
+    }
+
+    public void Dispose() => _seedConn?.Dispose();
+
+    private static string LiteFile(string relative, [CallerFilePath] string thisFile = "")
+        => File.ReadAllText(Path.GetFullPath(Path.Combine(Path.GetDirectoryName(thisFile)!, "..", "Lite", relative))).ReplaceLineEndings("\n");
+
+    private async Task<DuckDBConnection> SeedAsync()
+    {
+        if (_seedConn is null)
+        {
+            _seedConn = _duckDb.CreateConnection();
+            await _seedConn.OpenAsync();
+        }
+
+        return _seedConn;
+    }
+
+    // ---- R5: FinOps pickers are rolling only ----
+
+    [Fact]
+    public void RollingOnlyLimits_RefuseCalendarFixedAndSinceAndTooShort()
+    {
+        var now = new DateTime(2026, 10, 8, 12, 0, 0, DateTimeKind.Unspecified);
+        var oneHour = TimeSpan.FromHours(1);
+
+        Assert.Null(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromHours(36)), rollingOnly: true, oneHour));
+        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek), rollingOnly: true, oneHour));
+        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.FixedRange(now.AddDays(-3), now.AddDays(-2)), rollingOnly: true, oneHour));
+        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.SinceInstant(now.AddDays(-3)), rollingOnly: true, oneHour));
+        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)), rollingOnly: true, oneHour));
+        Assert.Null(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromHours(1)), rollingOnly: true, oneHour));
+
+        /* Not rolling only: a calendar period is fine, but the minimum span still refuses a short length. */
+        Assert.Null(TimeRangeLimits.Refusal(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek), rollingOnly: false, oneHour));
+        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)), rollingOnly: false, oneHour));
+    }
+
+    [Fact]
+    public void RollingOnlyCoerce_ReadsAFinishedPeriodAsTheLengthFromItsStartToNow()
+    {
+        var now = new DateTime(2026, 10, 8, 12, 0, 0, DateTimeKind.Unspecified);
+        var spec = TimeRangeLimits.Coerce(TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday), rollingOnly: true, TimeSpan.FromHours(1), now, TimeZoneInfo.Utc);
+
+        Assert.Equal(TimeRangeKind.Relative, spec.Kind);
+        Assert.Equal(TimeSpan.FromHours(36), spec.Span); /* yesterday starts Oct 7 00:00, 36 hours before Oct 8 12:00 */
+        Assert.Equal(TimeSpan.FromHours(1), TimeRangeLimits.Coerce(TimeRangeSpec.Relative(TimeSpan.FromMinutes(15)), true, TimeSpan.FromHours(1), now, TimeZoneInfo.Utc).Span);
+        var held = TimeRangeSpec.Relative(TimeSpan.FromHours(4));
+        Assert.Same(held, TimeRangeLimits.Coerce(held, true, TimeSpan.FromHours(1), now, TimeZoneInfo.Utc));
+    }
+
+    [Fact]
+    public void FinOps_EveryPickerIsConfiguredRollingOnly_HeatmapInWholeDays()
+    {
+        var code = LiteFile(Path.Combine("Controls", "FinOpsTab.xaml.cs"));
+        var xaml = LiteFile(Path.Combine("Controls", "FinOpsTab.xaml"));
+        var helper = LiteFile(Path.Combine("Helpers", "LiteTimeRange.cs"));
+
+        Assert.Equal(5, Regex.Matches(xaml, @"<ui:TimeRangePicker [^>]*Compact=""True""").Count);
+        Assert.Equal(4, Regex.Matches(code, @"LiteTimeRange\.ConfigureFinOpsPicker\(\w+TimeRangePicker, LiteTimeRange\.FinOpsMinSpan\)").Count);
+        Assert.Contains("LiteTimeRange.ConfigureFinOpsPicker(ObjectHeatmapWindowPicker, LiteTimeRange.FinOpsHeatmapMinSpan)", code, StringComparison.Ordinal);
+        Assert.Contains("picker.RollingOnly = true;", helper, StringComparison.Ordinal);
+        Assert.Contains("picker.Compact = true;", helper, StringComparison.Ordinal);
+        Assert.Equal(TimeSpan.FromHours(1), LiteTimeRange.FinOpsMinSpan);
+        Assert.Equal(TimeSpan.FromDays(1), LiteTimeRange.FinOpsHeatmapMinSpan);
+    }
+
+    // ---- R6: Job History end bound ahead of the cap ----
+
+    private async Task InsertRunAsync(int serverId, string jobId, DateTime wall)
+    {
+        var connection = await SeedAsync();
+        using var readLock = _duckDb.AcquireReadLock();
+        using var cmd = connection.CreateCommand();
+        cmd.CommandText = @"
+INSERT INTO job_history
+    (job_history_id, collection_time, server_id, server_name, instance_id, job_id, job_name,
+     job_enabled, category_name, step_id, step_name, run_status, run_status_desc, run_datetime,
+     run_duration_seconds, retries_attempted, message)
+VALUES
+    ($1, $2, $3, $4, $5, $6, $7, TRUE, 'Uncategorized (Local)', 0, '(Job outcome)', 1, 'The job succeeded.', $8, 30, 0, NULL)";
+        var id = _nextId++;
+        cmd.Parameters.Add(new DuckDBParameter { Value = id });
+        cmd.Parameters.Add(new DuckDBParameter { Value = DateTime.UtcNow });
+        cmd.Parameters.Add(new DuckDBParameter { Value = serverId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = $"S{serverId}" });
+        cmd.Parameters.Add(new DuckDBParameter { Value = id });
+        cmd.Parameters.Add(new DuckDBParameter { Value = jobId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = jobId });
+        cmd.Parameters.Add(new DuckDBParameter { Value = wall });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    /// <summary>
+    /// A window that ENDED two hours ago, with more runs after its end than the cap: the end is in the SQL ahead of the
+    /// LIMIT, so the cap is spent on the runs inside the window (the newest of them), not on the newer runs after it.
+    /// </summary>
+    [Fact]
+    public async Task JobHistory_EndBoundIsAppliedBeforeTheRowCap()
+    {
+        const int server = 701;
+        var host = DateTime.Now - DateTime.UtcNow; /* no collected clock: the machine's, so wall = utc + host offset */
+        DateTime Wall(DateTime utc)
+        {
+            var t = utc + host;
+            return new DateTime(t.Year, t.Month, t.Day, t.Hour, t.Minute, t.Second, DateTimeKind.Unspecified);
+        }
+
+        var now = DateTime.UtcNow;
+        var start = now.AddHours(-6);
+        var end = now.AddHours(-2);
+        for (var i = 0; i < 5; i++)
+        {
+            await InsertRunAsync(server, $"inside_{i}", Wall(end.AddMinutes(-10 * (i + 1))));
+        }
+
+        for (var i = 0; i < 6; i++)
+        {
+            await InsertRunAsync(server, $"after_{i}", Wall(end.AddMinutes(10 * (i + 1))));
+        }
+
+        var service = new LocalDataService(_duckDb);
+        var cap = 3;
+        var bounded = await service.GetJobHistoryAsync(start, cap, server, openTabClocks: null, windowEndUtc: end);
+        var unbounded = await service.GetJobHistoryAsync(start, cap, server);
+
+        Assert.Equal(cap, bounded.Count);
+        Assert.All(bounded, r => Assert.StartsWith("inside_", r.JobId));
+        Assert.Equal(new[] { "inside_0", "inside_1", "inside_2" }, bounded.Select(r => r.JobId).ToArray()); /* newest inside the window first */
+        Assert.All(unbounded, r => Assert.StartsWith("after_", r.JobId)); /* the old shape spent the whole cap after the end */
+    }
+
+    [Fact]
+    public void JobHistoryTab_PassesTheRangeEndToTheRead_AndTheEndIsExclusive()
+    {
+        var tab = LiteFile(Path.Combine("Controls", "JobHistoryTab.xaml.cs"));
+        var sql = LiteFile(Path.Combine("Services", "LocalDataService.JobHistory.cs"));
+
+        Assert.Contains("GetJobHistoryWithClocksAsync(startUtc, RowCap, serverId, openTabClocks, rangeEndUtc)", tab, StringComparison.Ordinal);
+        Assert.Contains("LiteTimeRange.BoundsOf(RangePicker, 24, nowUtc)", tab, StringComparison.Ordinal);
+        Assert.Equal(2, Regex.Matches(sql, @"\{endClause\}").Count); /* job_stats and base, both ahead of the LIMIT */
+        Assert.Contains("run_datetime < $5", sql, StringComparison.Ordinal);
+    }
+
+    // ---- Alert History: start and exclusive end, Dismiss All scope ----
+
+    private async Task InsertAlertAsync(DateTime alertTimeUtc, string metric)
+    {
+        var connection = await SeedAsync();
+        using var readLock = _duckDb.AcquireReadLock();
+        using var cmd = connection.CreateCommand();
+        cmd.CommandText = @"
+INSERT INTO config_alert_log (alert_time, server_id, server_name, metric_name, current_value, threshold_value, alert_sent, notification_type)
+VALUES ($1, 702, 'S702', $2, 1, 1, TRUE, 'tray')";
+        cmd.Parameters.Add(new DuckDBParameter { Value = alertTimeUtc });
+        cmd.Parameters.Add(new DuckDBParameter { Value = metric });
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    [Fact]
+    public async Task AlertHistory_FinishedRangeShowsNoAlertAfterItsEnd_AndDismissAllTouchesOnlyThoseRows()
+    {
+        var now = DateTime.UtcNow;
+        var start = now.AddHours(-10);
+        var end = now.AddHours(-4);
+        await InsertAlertAsync(end.AddHours(-2), "inside_a");
+        await InsertAlertAsync(end.AddHours(-1), "inside_b");
+        await InsertAlertAsync(end, "at_end"); /* the end is exclusive */
+        await InsertAlertAsync(end.AddHours(1), "after_a");
+        await InsertAlertAsync(end.AddHours(2), "after_b");
+
+        var service = new LocalDataService(_duckDb);
+        var finished = await service.GetAlertHistoryWindowAsync(start, end, serverId: 702, limit: 100);
+        Assert.Equal(new[] { "inside_b", "inside_a" }, finished.Select(a => a.MetricName).ToArray());
+
+        var live = await service.GetAlertHistoryWindowAsync(start, null, serverId: 702, limit: 100);
+        Assert.Equal(5, live.Count);
+
+        /* The cap counts the rows inside the window, not the newer ones after its end. */
+        var capped = await service.GetAlertHistoryWindowAsync(start, end, serverId: 702, limit: 1);
+        Assert.Equal("inside_b", Assert.Single(capped).MetricName);
+
+        var dismissed = await service.DismissAllVisibleAlertsWindowAsync(start, end, serverId: 702);
+        Assert.Equal(2, dismissed);
+        var remaining = await service.GetAlertHistoryWindowAsync(start, null, serverId: 702, limit: 100);
+        Assert.Equal(new[] { "after_b", "after_a", "at_end" }, remaining.Select(a => a.MetricName).ToArray());
+    }
+
+    // ---- R8: Alert History's longest choice ----
+
+    [Theory]
+    [InlineData(2026, 10, 8, 92)] /* Jul 8 to Oct 8 */
+    [InlineData(2026, 3, 1, 90)]  /* Dec 1 to Mar 1 */
+    [InlineData(2026, 6, 1, 92)]  /* Mar 1 to Jun 1 */
+    public void AlertHistoryLongest_IsTheAlertLogsRetentionInDays(int year, int month, int day, int days)
+    {
+        var now = new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+        Assert.Equal(TimeSpan.FromDays(days), LiteTimeRange.AlertHistoryLongest(now));
+        Assert.Equal(days + "d", LiteTimeRange.AlertHistoryLongestText(now));
+        Assert.Equal(3, RetentionService.ArchiveRetentionMonths);
+        Assert.True(LiteTimeRange.AlertHistoryLongest(now) <= TimeSpan.FromDays(365));
+
+        /* It types into the picker's grammar as a rolling length. */
+        var parsed = TimeRangeParser.Parse(LiteTimeRange.AlertHistoryLongestText(now), now, TimeZoneInfo.Utc);
+        Assert.True(parsed.Ok);
+        Assert.Equal(days * 24, parsed.Spec!.WholeHours);
+    }
+
+    // ---- R3: the sample note names the sub-tab's main collector ----
+
+    [Theory]
+    [InlineData("Wait Stats", null, "wait_stats")]
+    [InlineData("Queries", "Active Queries", "query_snapshots")]
+    [InlineData("Queries", "Top Procedures by Duration", "procedure_stats")]
+    [InlineData("Queries", "Query Store by Duration", "query_store")]
+    [InlineData("Memory", "Memory Clerks", "memory_clerks")]
+    [InlineData("Memory", "Memory Grants", "memory_grant_stats")]
+    [InlineData("Blocking", "Current Waits", "waiting_tasks")]
+    [InlineData("Blocking", "Deadlocks", "deadlocks")]
+    [InlineData("System Events", "Default Trace", "default_trace_events")]
+    [InlineData("System Events", "Severe Errors", "system_health_events")]
+    [InlineData("Latches & Spinlocks", null, "latch_stats")]
+    [InlineData("Running Jobs", null, "running_jobs")]
+    [InlineData("Overview", null, null)]
+    [InlineData("Configuration", "Trace Flags", null)]
+    [InlineData("Daily Summary", null, null)]
+    public void MainCollectorFor_NamesTheSubTabsOwnCollector(string tab, string? sub, string? expected)
+        => Assert.Equal(expected, LiteTimeRange.MainCollectorFor(tab, sub));
+
+    [Fact]
+    public void MainCollectors_AreRealCollectorsWithAShippedCadence()
+    {
+        var names = new[]
+        {
+            "wait_stats", "query_stats", "query_snapshots", "procedure_stats", "query_store", "plan_correction", "cpu_utilization",
+            "memory_stats", "memory_clerks", "memory_grant_stats", "memory_pressure_events", "file_io_stats", "tempdb_stats",
+            "blocked_process_report", "waiting_tasks", "deadlocks", "perfmon_stats", "running_jobs", "latch_stats",
+            "cpu_scheduler_stats", "plan_cache_stats", "session_stats", "default_trace_events", "system_health_events"
+        };
+        foreach (var name in names)
+        {
+            Assert.True(CollectorScheduleDefaults.All.ContainsKey(name), name);
+        }
+    }
+
+    [Fact]
+    public void SampleIntervalForCollector_UsesTheSchedule_ThenTheShippedDefault()
+    {
+        Assert.Null(LiteTimeRange.SampleIntervalForCollector(null, null));
+        Assert.Equal(TimeSpan.FromMinutes(5), LiteTimeRange.SampleIntervalForCollector("query_store", null)); /* shipped default */
+        Assert.Equal(TimeSpan.FromMinutes(15), LiteTimeRange.SampleIntervalForCollector("query_store", new CollectorSchedule { Name = "query_store", Enabled = true, FrequencyMinutes = 15 }));
+        Assert.Null(LiteTimeRange.SampleIntervalForCollector("query_store", new CollectorSchedule { Name = "query_store", Enabled = false, FrequencyMinutes = 5 }));
+        Assert.Null(LiteTimeRange.SampleIntervalForCollector("server_config", null)); /* on load: no cadence */
+    }
+
+    [Fact]
+    public void ServerTab_SampleNoteFollowsTheSubTabOnScreen_NotWaitStatsForEverything()
+    {
+        var tab = LiteFile(Path.Combine("Controls", "ServerTab.TimeRange.cs"));
+        var main = LiteFile("MainWindow.xaml.cs");
+
+        Assert.DoesNotContain("MainCollectorName", tab, StringComparison.Ordinal);
+        Assert.Contains("CurrentMainCollector() is { } collector ? _sampleIntervalProvider?.Invoke(collector)", tab, StringComparison.Ordinal);
+        Assert.Contains("Selector.SelectionChangedEvent", tab, StringComparison.Ordinal);
+        Assert.Contains("SampleIntervalForCollector(", main, StringComparison.Ordinal);
+        Assert.DoesNotContain("\"wait_stats\"", main.Substring(main.IndexOf("SetSampleIntervalSource", StringComparison.Ordinal), 600), StringComparison.Ordinal);
+    }
+
+    // ---- R7: every banner site feeds the picker's data start ----
+
+    [Fact]
+    public void EveryBannerSite_FeedsThePickersDataStart()
+    {
+        /* The call sites of ApplyWindowFloorToBanner outside its definition, by file. A new site must either feed the picker
+           (ServerTab.FeedDataStart / the Job History tab's onFloor) or be added here with the reason it cannot. */
+        var expected = new[]
+        {
+            ("Controls/JobHistoryTab.xaml.cs", 1, "onFloor?.Invoke(floor)"),                       /* the tab's own picker */
+            ("Controls/LiteBlockingLaneDataStart.cs", 1, "onStartChosen?.Invoke(start)"),          /* Overview lanes, fed by the tab */
+            ("Controls/ServerTab.BlockingChartsDataStart.cs", 1, "FeedDataStart("),
+            ("Controls/ServerTab.Refresh.cs", 1, "FeedDataStart(LiteTimeRange.CollectorOfRelation(relation), floor)"),
+            ("Windows/CollectionLogWindow.xaml.cs", 1, null),                                      /* its own window: no picker */
+        };
+
+        var root = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(ThisFile())!, "..", "Lite"));
+        var sites = Directory.EnumerateFiles(root, "*.cs", SearchOption.AllDirectories)
+            .Where(f => !f.Contains(Path.DirectorySeparatorChar + "obj" + Path.DirectorySeparatorChar) && !f.Contains(Path.DirectorySeparatorChar + "bin" + Path.DirectorySeparatorChar))
+            .Select(f => (File: f, Calls: Regex.Matches(File.ReadAllText(f), @"(?<![/<=.\w])(ServerTab\.)?ApplyWindowFloorToBanner\(", RegexOptions.None)
+                .Count(m => !IsDocOrDefinition(File.ReadAllText(f), m.Index))))
+            .Where(x => x.Calls > 0)
+            .ToList();
+
+        Assert.Equal(expected.Length, sites.Count);
+        foreach (var (relative, calls, feed) in expected)
+        {
+            var full = Path.Combine(root, relative.Replace('/', Path.DirectorySeparatorChar));
+            var site = Assert.Single(sites, s => s.File == full);
+            Assert.Equal(calls, site.Calls);
+            if (feed is not null)
+            {
+                Assert.Contains(feed, File.ReadAllText(full), StringComparison.Ordinal);
+            }
+        }
+
+        /* The central funnel feeds for every relation, and the tab points the picker at the page on screen. */
+        var refresh = LiteFile(Path.Combine("Controls", "ServerTab.Refresh.cs"));
+        Assert.DoesNotContain("if (relation == QueryWindowRelation.QueryStats)\n        {\n            RangePicker.DataStartUtc", refresh, StringComparison.Ordinal);
+        Assert.Contains("CorrelatedLanes.DataStartFound +=", LiteFile(Path.Combine("Controls", "ServerTab.xaml.cs")), StringComparison.Ordinal);
+    }
+
+    private static string ThisFile([CallerFilePath] string path = "") => path;
+
+    private static bool IsDocOrDefinition(string text, int index)
+    {
+        var lineStart = text.LastIndexOf('\n', index) + 1;
+        var line = text.Substring(lineStart, text.IndexOf('\n', index) is var e and >= 0 ? e - lineStart : text.Length - lineStart).TrimStart();
+        return line.StartsWith("//", StringComparison.Ordinal) || line.StartsWith("///", StringComparison.Ordinal)
+            || line.StartsWith("*", StringComparison.Ordinal) || line.StartsWith("/*", StringComparison.Ordinal)
+            || line.Contains("internal static bool ApplyWindowFloorToBanner(", StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void CollectorOfRelation_NamesARealCollectorForEveryScheduledRelation()
+    {
+        foreach (var relation in Enum.GetValues<QueryWindowRelation>())
+        {
+            var name = LiteTimeRange.CollectorOfRelation(relation);
+            if (name is not null)
+            {
+                Assert.True(CollectorScheduleDefaults.All.ContainsKey(name), relation + " -> " + name);
+            }
+        }
+    }
+}
diff --git a/Lite.Tests/ServerTabHeldRangeTests.cs b/Lite.Tests/ServerTabHeldRangeTests.cs
index 4b69550111..a10e3bdb32 100644
--- a/Lite.Tests/ServerTabHeldRangeTests.cs
+++ b/Lite.Tests/ServerTabHeldRangeTests.cs
@@ -291,7 +291,8 @@ public void TheQueryStatsProbe_FeedsThePickersDataStart_WithoutANewQuery()
         var refresh = CodeOnly(ReadControl("ServerTab.Refresh.cs"));
         var body = MethodBody(refresh, "private async System.Threading.Tasks.Task RefreshWindowTruncatedBannerAsync(");
 
-        Assert.Contains("RangePicker.DataStartUtc = LiteTimeRange.DataStartFor(floor, DateTime.UtcNow);", body, StringComparison.Ordinal);
+        /* #5562 R7: every relation feeds, keyed by its collector, and the tab shows the floor of the page on screen. */
+        Assert.Contains("FeedDataStart(LiteTimeRange.CollectorOfRelation(relation), floor);", body, StringComparison.Ordinal);
         Assert.Single(Regex.Matches(body, @"GetQueryWindowFloorAsync\("));
     }
 
diff --git a/Lite/Services/LocalDataService.JobHistory.cs b/Lite/Services/LocalDataService.JobHistory.cs
index e2b0bf0d6d..85390284d1 100644
--- a/Lite/Services/LocalDataService.JobHistory.cs
+++ b/Lite/Services/LocalDataService.JobHistory.cs
@@ -244,18 +244,31 @@ internal static List<JobHistoryRow> ApplyJobHistoryWindow(List<JobHistoryRow> ro
     /// each with its run time converted to UTC through <paramref name="clock"/>. Not yet held to the exact window.</summary>
     private async Task<List<JobHistoryRow>> ReadJobHistoryForServerAsync(int serverId, ServerClock clock, DateTime windowStartUtc, int limit, DateTime? windowEndUtc)
     {
-        var items = await ReadJobHistoryForServerOnceAsync(serverId, clock, windowStartUtc, limit, windowEndUtc);
-        if (windowEndUtc is not { } end || limit <= 0 || items.Count < limit)
+        var readLimit = limit;
+        var items = await ReadJobHistoryForServerOnceAsync(serverId, clock, windowStartUtc, readLimit, windowEndUtc);
+        if (windowEndUtc is not { } end || limit <= 0)
         {
             return items;
         }
 
         /* #5562: the SQL end bound is the server-local end widened by an hour (a daylight-saving change next to the end
-           moves the stored wall clock by an hour against the instant), so a run in that margin can sit among the newest
-           rows and displace a run inside the window from the cap. The margin rows are the newest ones, so they are all in
-           the first read: count them and read again with that many more rows, and the cap lands on the window. */
-        var outside = items.Count(r => r.RunDateTimeUtc is { } runUtc && runUtc >= end);
-        return outside == 0 ? items : await ReadJobHistoryForServerOnceAsync(serverId, clock, windowStartUtc, limit + outside, windowEndUtc);
+           moves the stored wall clock by an hour against the instant), so runs in that margin can sit among the newest rows
+           and displace runs inside the window from the cap. The margin runs are the newest ones: while the read came back
+           full and holds fewer than <c>limit</c> runs inside the window, read again with room for the missing
+           ones, so the cap lands on the window. A read that came back short has reached the oldest row, so it is complete. */
+        while (items.Count >= readLimit)
+        {
+            var inside = items.Count(r => r.RunDateTimeUtc is { } runUtc && runUtc < end);
+            if (inside >= limit)
+            {
+                break;
+            }
+
+            readLimit += limit - inside;
+            items = await ReadJobHistoryForServerOnceAsync(serverId, clock, windowStartUtc, readLimit, windowEndUtc);
+        }
+
+        return items;
     }
 
     private async Task<List<JobHistoryRow>> ReadJobHistoryForServerOnceAsync(int serverId, ServerClock clock, DateTime windowStartUtc, int limit, DateTime? windowEndUtc)

From 83b11ba79b82183fed7c30e890fff09496903154 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:32:31 -0400
Subject: [PATCH 18/33] Lite: FinOps and Alert History use the shared control's
 RollingUnit and SetLongestChoice (#5562)

---
 Lite.Tests/LiteTimeRangeGapTests.cs    | 51 ++++++++------------------
 Lite/Controls/AlertsHistoryTab.xaml.cs |  5 ++-
 Lite/Controls/FinOpsTab.xaml.cs        | 10 ++---
 Lite/Helpers/LiteTimeRange.cs          | 21 ++++-------
 4 files changed, 30 insertions(+), 57 deletions(-)

diff --git a/Lite.Tests/LiteTimeRangeGapTests.cs b/Lite.Tests/LiteTimeRangeGapTests.cs
index 753ffed30b..dcfc249988 100644
--- a/Lite.Tests/LiteTimeRangeGapTests.cs
+++ b/Lite.Tests/LiteTimeRangeGapTests.cs
@@ -59,34 +59,18 @@ private async Task<DuckDBConnection> SeedAsync()
     // ---- R5: FinOps pickers are rolling only ----
 
     [Fact]
-    public void RollingOnlyLimits_RefuseCalendarFixedAndSinceAndTooShort()
+    public void RollingUnitRule_RefusesCalendarFixedSinceAndTooShort_ForAFinOpsList()
     {
         var now = new DateTime(2026, 10, 8, 12, 0, 0, DateTimeKind.Unspecified);
-        var oneHour = TimeSpan.FromHours(1);
-
-        Assert.Null(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromHours(36)), rollingOnly: true, oneHour));
-        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek), rollingOnly: true, oneHour));
-        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.FixedRange(now.AddDays(-3), now.AddDays(-2)), rollingOnly: true, oneHour));
-        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.SinceInstant(now.AddDays(-3)), rollingOnly: true, oneHour));
-        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)), rollingOnly: true, oneHour));
-        Assert.Null(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromHours(1)), rollingOnly: true, oneHour));
-
-        /* Not rolling only: a calendar period is fine, but the minimum span still refuses a short length. */
-        Assert.Null(TimeRangeLimits.Refusal(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek), rollingOnly: false, oneHour));
-        Assert.NotNull(TimeRangeLimits.Refusal(TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)), rollingOnly: false, oneHour));
-    }
-
-    [Fact]
-    public void RollingOnlyCoerce_ReadsAFinishedPeriodAsTheLengthFromItsStartToNow()
-    {
-        var now = new DateTime(2026, 10, 8, 12, 0, 0, DateTimeKind.Unspecified);
-        var spec = TimeRangeLimits.Coerce(TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday), rollingOnly: true, TimeSpan.FromHours(1), now, TimeZoneInfo.Utc);
-
-        Assert.Equal(TimeRangeKind.Relative, spec.Kind);
-        Assert.Equal(TimeSpan.FromHours(36), spec.Span); /* yesterday starts Oct 7 00:00, 36 hours before Oct 8 12:00 */
-        Assert.Equal(TimeSpan.FromHours(1), TimeRangeLimits.Coerce(TimeRangeSpec.Relative(TimeSpan.FromMinutes(15)), true, TimeSpan.FromHours(1), now, TimeZoneInfo.Utc).Span);
-        var held = TimeRangeSpec.Relative(TimeSpan.FromHours(4));
-        Assert.Same(held, TimeRangeLimits.Coerce(held, true, TimeSpan.FromHours(1), now, TimeZoneInfo.Utc));
+        var hour = RollingUnitRule.Hour;
+
+        Assert.True(RollingUnitRule.Admits(TimeRangeSpec.Relative(TimeSpan.FromHours(36)), hour));
+        Assert.False(RollingUnitRule.Admits(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek), hour));
+        Assert.False(RollingUnitRule.Admits(TimeRangeSpec.FixedRange(now.AddDays(-3), now.AddDays(-2)), hour));
+        Assert.False(RollingUnitRule.Admits(TimeRangeSpec.SinceInstant(now.AddDays(-3)), hour));
+        Assert.False(RollingUnitRule.Admits(TimeRangeSpec.Relative(TimeSpan.FromMinutes(30)), hour));
+        Assert.False(RollingUnitRule.Admits(TimeRangeSpec.Relative(TimeSpan.FromHours(36)), RollingUnitRule.Day)); /* the heatmap takes whole days */
+        Assert.True(RollingUnitRule.Admits(TimeRangeSpec.Relative(TimeSpan.FromDays(30)), RollingUnitRule.Day));
     }
 
     [Fact]
@@ -97,12 +81,10 @@ public void FinOps_EveryPickerIsConfiguredRollingOnly_HeatmapInWholeDays()
         var helper = LiteFile(Path.Combine("Helpers", "LiteTimeRange.cs"));
 
         Assert.Equal(5, Regex.Matches(xaml, @"<ui:TimeRangePicker [^>]*Compact=""True""").Count);
-        Assert.Equal(4, Regex.Matches(code, @"LiteTimeRange\.ConfigureFinOpsPicker\(\w+TimeRangePicker, LiteTimeRange\.FinOpsMinSpan\)").Count);
-        Assert.Contains("LiteTimeRange.ConfigureFinOpsPicker(ObjectHeatmapWindowPicker, LiteTimeRange.FinOpsHeatmapMinSpan)", code, StringComparison.Ordinal);
-        Assert.Contains("picker.RollingOnly = true;", helper, StringComparison.Ordinal);
+        Assert.Equal(4, Regex.Matches(code, @"LiteTimeRange\.ConfigureFinOpsPicker\(\w+TimeRangePicker, RollingUnitRule\.Hour\)").Count);
+        Assert.Contains("LiteTimeRange.ConfigureFinOpsPicker(ObjectHeatmapWindowPicker, RollingUnitRule.Day)", code, StringComparison.Ordinal);
+        Assert.Contains("picker.RollingUnit = unit;", helper, StringComparison.Ordinal);
         Assert.Contains("picker.Compact = true;", helper, StringComparison.Ordinal);
-        Assert.Equal(TimeSpan.FromHours(1), LiteTimeRange.FinOpsMinSpan);
-        Assert.Equal(TimeSpan.FromDays(1), LiteTimeRange.FinOpsHeatmapMinSpan);
     }
 
     // ---- R6: Job History end bound ahead of the cap ----
@@ -236,14 +218,10 @@ public void AlertHistoryLongest_IsTheAlertLogsRetentionInDays(int year, int mont
     {
         var now = new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
         Assert.Equal(TimeSpan.FromDays(days), LiteTimeRange.AlertHistoryLongest(now));
-        Assert.Equal(days + "d", LiteTimeRange.AlertHistoryLongestText(now));
+        Assert.Equal(TimeRangeSpec.Relative(TimeSpan.FromDays(days)), LiteTimeRange.AlertHistoryLongestChoice(now));
         Assert.Equal(3, RetentionService.ArchiveRetentionMonths);
         Assert.True(LiteTimeRange.AlertHistoryLongest(now) <= TimeSpan.FromDays(365));
 
-        /* It types into the picker's grammar as a rolling length. */
-        var parsed = TimeRangeParser.Parse(LiteTimeRange.AlertHistoryLongestText(now), now, TimeZoneInfo.Utc);
-        Assert.True(parsed.Ok);
-        Assert.Equal(days * 24, parsed.Spec!.WholeHours);
     }
 
     // ---- R3: the sample note names the sub-tab's main collector ----
@@ -345,6 +323,7 @@ public void EveryBannerSite_FeedsThePickersDataStart()
         /* The central funnel feeds for every relation, and the tab points the picker at the page on screen. */
         var refresh = LiteFile(Path.Combine("Controls", "ServerTab.Refresh.cs"));
         Assert.DoesNotContain("if (relation == QueryWindowRelation.QueryStats)\n        {\n            RangePicker.DataStartUtc", refresh, StringComparison.Ordinal);
+        Assert.Contains("RangePicker.SetLongestChoice(LiteTimeRange.AlertHistoryLongestChoice(", LiteFile(Path.Combine("Controls", "AlertsHistoryTab.xaml.cs")), StringComparison.Ordinal);
         Assert.Contains("CorrelatedLanes.DataStartFound +=", LiteFile(Path.Combine("Controls", "ServerTab.xaml.cs")), StringComparison.Ordinal);
     }
 
diff --git a/Lite/Controls/AlertsHistoryTab.xaml.cs b/Lite/Controls/AlertsHistoryTab.xaml.cs
index 63a7d41ed6..22a350859b 100644
--- a/Lite/Controls/AlertsHistoryTab.xaml.cs
+++ b/Lite/Controls/AlertsHistoryTab.xaml.cs
@@ -63,8 +63,9 @@ public AlertsHistoryTab()
     {
         InitializeComponent();
         RangePicker.Value = TimeRangePresets.FromLegacyHours(24)!; /* 24 hours, as the list opened */
-        /* R8: the old "All" item is a typed span as long as the alert log is kept (3 months on Lite, RetentionService.ArchiveRetentionMonths). */
-        RangePicker.ToolTip = $"Alerts are kept for {RetentionService.ArchiveRetentionMonths} months: type {LiteTimeRange.AlertHistoryLongestText(DateTime.UtcNow)} to see them all.";
+        /* R8: "All" is a span as long as the alert log is kept (3 months on Lite, RetentionService.ArchiveRetentionMonths), through
+           the shared control's longest choice, as the Darling Viewer's Alert History does. */
+        RangePicker.SetLongestChoice(LiteTimeRange.AlertHistoryLongestChoice(DateTime.UtcNow), "All");
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
diff --git a/Lite/Controls/FinOpsTab.xaml.cs b/Lite/Controls/FinOpsTab.xaml.cs
index 02646bf63a..5cba4ebb0b 100644
--- a/Lite/Controls/FinOpsTab.xaml.cs
+++ b/Lite/Controls/FinOpsTab.xaml.cs
@@ -82,11 +82,11 @@ public FinOpsTab()
         InitializeComponent();
         /* #5562: every list opened on the last 24 hours (1d); the heatmap on 30 days (1mo). */
         /* R5: the lists and the heatmap read "hours back from now", so each picker is rolling only (the heatmap in whole days). */
-        LiteTimeRange.ConfigureFinOpsPicker(ResourceUsageTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
-        LiteTimeRange.ConfigureFinOpsPicker(WaitStatsTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
-        LiteTimeRange.ConfigureFinOpsPicker(ExpensiveQueriesTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
-        LiteTimeRange.ConfigureFinOpsPicker(HighImpactTimeRangePicker, LiteTimeRange.FinOpsMinSpan);
-        LiteTimeRange.ConfigureFinOpsPicker(ObjectHeatmapWindowPicker, LiteTimeRange.FinOpsHeatmapMinSpan);
+        LiteTimeRange.ConfigureFinOpsPicker(ResourceUsageTimeRangePicker, RollingUnitRule.Hour);
+        LiteTimeRange.ConfigureFinOpsPicker(WaitStatsTimeRangePicker, RollingUnitRule.Hour);
+        LiteTimeRange.ConfigureFinOpsPicker(ExpensiveQueriesTimeRangePicker, RollingUnitRule.Hour);
+        LiteTimeRange.ConfigureFinOpsPicker(HighImpactTimeRangePicker, RollingUnitRule.Hour);
+        LiteTimeRange.ConfigureFinOpsPicker(ObjectHeatmapWindowPicker, RollingUnitRule.Day);
         var day = TimeRangePresets.FromLegacyHours(24)!;
         ResourceUsageTimeRangePicker.Value = day;
         WaitStatsTimeRangePicker.Value = day;
diff --git a/Lite/Helpers/LiteTimeRange.cs b/Lite/Helpers/LiteTimeRange.cs
index fa28358080..8ffa339fa0 100644
--- a/Lite/Helpers/LiteTimeRange.cs
+++ b/Lite/Helpers/LiteTimeRange.cs
@@ -21,21 +21,15 @@ namespace PerformanceMonitorLite.Helpers;
 /// </summary>
 internal static class LiteTimeRange
 {
-    /// <summary>The shortest FinOps list range: every FinOps read is whole hours back from now (#5562 R5).</summary>
-    internal static readonly TimeSpan FinOpsMinSpan = TimeSpan.FromHours(1);
-
-    /// <summary>The shortest heatmap window: the heatmap reads whole days.</summary>
-    internal static readonly TimeSpan FinOpsHeatmapMinSpan = TimeSpan.FromDays(1);
-
     /// <summary>
-    /// A FinOps picker (#5562 R5): compact, rolling only (no calendar period, no start-and-end, no 'since') and at least
-    /// <paramref name="minSpan"/>, because the read behind it is "hours back from now" and could not honor a finished range.
+    /// A FinOps picker (#5562 R5): compact and rolling only, in whole <paramref name="unit"/>s (<see cref="RollingUnitRule.Hour"/> for
+    /// a list, <see cref="RollingUnitRule.Day"/> for the heatmap), through the shared control's <c>RollingUnit</c>: the read behind it
+    /// is "N units back from now" and could not honor a finished range. The Darling Viewer's FinOps tab sets the same two units.
     /// </summary>
-    internal static void ConfigureFinOpsPicker(TimeRangePicker picker, TimeSpan minSpan)
+    internal static void ConfigureFinOpsPicker(TimeRangePicker picker, TimeSpan unit)
     {
         picker.Compact = true;
-        picker.RollingOnly = true;
-        picker.MinSpan = minSpan;
+        picker.RollingUnit = unit;
     }
 
     /// <summary>The range a fresh install opens on: the old default of four hours.</summary>
@@ -116,9 +110,8 @@ internal static TimeSpan AlertHistoryLongest(DateTime utcNow)
         return TimeSpan.FromDays(Math.Min(days, 365));
     }
 
-    /// <summary>What to type for <see cref="AlertHistoryLongest"/>: "92d".</summary>
-    internal static string AlertHistoryLongestText(DateTime utcNow)
-        => ((int)AlertHistoryLongest(utcNow).TotalDays) + "d";
+    /// <summary>The longest choice as the shared control's extra rolling choice (<c>SetLongestChoice</c>), the Viewer's "All" at Lite's retention.</summary>
+    internal static TimeRangeSpec AlertHistoryLongestChoice(DateTime utcNow) => TimeRangeSpec.Relative(AlertHistoryLongest(utcNow));
 
     /// <summary>True when <paramref name="range"/> carries its own instants rather than 'the last N hours'.</summary>
     internal static bool HasExplicitInstants(ResolvedTimeRange range) => range.Spec.WholeHours is not > 0;

From ec600b5c19b987fac3b418d6ea76f289c889367f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:53:46 -0400
Subject: [PATCH 19/33] Web and MCP: raw-table trends reach 30 days, Alert
 History 90 days, Storage Growth reach from the catalog (#5562)

---
 .../AlertHistoryRangePageTests.cs             | 21 ++--
 ...rfmonWaitStatisticsArtifactMcpLiveTests.cs | 98 +++++++++++++++++++
 Darling/Darling.Tests/WebPageRangeTests.cs    |  6 +-
 .../Darling.Tests/WebReadReachLiveTests.cs    | 12 ++-
 Darling/Darling.Tests/WebReadReachTests.cs    | 53 +++++++++-
 .../alert-history-range-harness.mjs           |  3 +-
 .../finops-storage-growth-window-harness.mjs  |  7 +-
 Darling/Darling.Tests/page-range-harness.mjs  |  2 +-
 .../DarlingWebEndpoints.cs                    | 11 +++
 .../Mcp/DarlingMcpAlertTools.cs               |  5 +-
 .../Mcp/DarlingMcpBlockingTools.cs            | 15 +--
 .../Mcp/DarlingMcpDataTools.cs                | 15 +--
 .../Mcp/DarlingMcpPgCpuUtilizationTools.cs    |  5 +-
 .../Mcp/DarlingMcpPgTrendTools.cs             | 10 +-
 .../Mcp/DarlingMcpQueryHeatmapTools.cs        |  5 +-
 .../Mcp/DarlingMcpTrendTools.cs               | 16 +--
 .../Mcp/DarlingTrendReader.cs                 |  8 +-
 .../WebReadReach.cs                           | 70 +++++++++----
 .../wwwroot/js/page-range.js                  |  7 +-
 .../wwwroot/js/pages/alerts.js                |  7 +-
 .../wwwroot/js/pages/finops/storage-growth.js |  8 +-
 .../wwwroot/js/pages/finops/window.js         |  4 +-
 22 files changed, 308 insertions(+), 80 deletions(-)

diff --git a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
index f2424232f4..78ac40bbb0 100644
--- a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
+++ b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
@@ -49,12 +49,12 @@ public void NoWindowOrLimitIsOfferedThatTheToolOrTheDispatchLayerRefuses()
     {
         var page = Page();
         // #5562 R8: no hand-listed windows and no "All". The picker takes its reach from the catalog's max_hours for the read, which is
-        // the 168 hours the read's validator accepts, so a longer range is greyed out with the reason and never clamped. The alert table
-        // keeps 90 days (AlertHistoryRetentionDays, DarlingRetention.cs), but the web read stops at the common reach (R2).
+        // the 2160 hours (90 days) the read's validator accepts, so a longer range is greyed out with the reason and never clamped. That
+        // is the alert table's retention (AlertHistoryRetentionDays, DarlingRetention.cs), the longest choice the Viewer offers (R8, L4b).
         Assert.DoesNotContain("WINDOW_CHOICES", page);
         Assert.Contains("read: \"get_alert_history\"", page);
         Assert.Contains("pageRangePicker({", page);
-        Assert.Equal(PerformanceMonitor.Common.McpHelpers.MaxHoursBack, PerformanceMonitor.Darling.Service.WebReadReach.All["get_alert_history"].MaxHours);
+        Assert.Equal(24 * PerformanceMonitor.Darling.Storage.DarlingRetentionHorizons.AlertHistoryRetentionDays, PerformanceMonitor.Darling.Service.WebReadReach.All["get_alert_history"].MaxHours);
         Assert.Equal(90, PerformanceMonitor.Darling.Storage.DarlingRetentionHorizons.AlertHistoryRetentionDays);
 
         var limits = System.Text.RegularExpressions.Regex.Match(page, "const LIMIT_CHOICES = \\[([0-9, ]+)\\]").Groups[1].Value
@@ -126,12 +126,12 @@ public void EachChoiceReachesTheRead()
         Assert.Equal("1000", Get(dismissed, "limit"));
         Assert.Equal("srv-b", Get(dismissed, "server_name"));
 
-        // The popup offers the short presets and the calendar periods within 7 days; the longer ones are greyed out, never clamped.
-        Assert.Equal("Past 5 minutes,Past 15 minutes,Past 30 minutes,Past hour,Past 4 hours,Past day,Past 2 days,Past week,Today,Yesterday,Week to Date,Previous Week",
+        // The popup offers every preset and calendar period within the catalog's 90 days; the longer ones are greyed out, never clamped.
+        Assert.Equal("Past 5 minutes,Past 15 minutes,Past 30 minutes,Past hour,Past 4 hours,Past day,Past 2 days,Past week,Past 30 days,Today,Yesterday,Week to Date,Previous Week,Month to Date,Previous Month",
             string.Join(",", r.GetProperty("windowOptions").EnumerateArray().Select(e => e.GetString())));
-        Assert.Equal("Past 30 days,Month to Date,Previous Month,Year to Date,Previous Year",
+        Assert.Equal("Year to Date,Previous Year",
             string.Join(",", r.GetProperty("windowGreyed").EnumerateArray().Select(e => e.GetString())));
-        Assert.Equal("This page's reads reach at most 7 days back.", r.GetProperty("refused").GetString());
+        Assert.Equal("This page's reads reach at most 90 days back.", r.GetProperty("refused").GetString());
         // A finished range sends its end as as_of; a shorter-than-an-hour range reads the whole hour.
         Assert.EndsWith("Z", Get(r.GetProperty("finished"), "as_of"));
         Assert.Equal("1", Get(r.GetProperty("thirtyMinutes"), "hours_back"));
@@ -198,12 +198,13 @@ public void TwoServersThatShareADisplayNameKeepBothRows()
     }
 
     [Fact]
-    public void TheRangePickerSaysTheWebReadsAtMostSevenDays()
+    public void TheRangePickerTakesItsReachFromTheCatalog_NinetyDays()
     {
         // #5562: the picker greys out what the read cannot reach and says why (the catalog's max_hours), so the page needs no hand-written
-        // "at most 7 days" tooltip; the reach is the read's own 168 hours.
+        // tooltip; the reach is the read's own 2160 hours, the alert table's retention (L4b).
         Assert.DoesNotContain("The web reads at most 7 days of alert history, so there is no All choice.", Page());
-        Assert.Contains("the web read stops at the common 7 day reach", Page());
+        Assert.DoesNotContain("the web read stops at the common 7 day reach", Page());
+        Assert.Contains("get_alert_history reaches 2160 hours, 90 days", Page());
     }
 
     [Fact]
diff --git a/Darling/Darling.Tests/PerfmonWaitStatisticsArtifactMcpLiveTests.cs b/Darling/Darling.Tests/PerfmonWaitStatisticsArtifactMcpLiveTests.cs
index 0dce19e3fd..66a2974c49 100644
--- a/Darling/Darling.Tests/PerfmonWaitStatisticsArtifactMcpLiveTests.cs
+++ b/Darling/Darling.Tests/PerfmonWaitStatisticsArtifactMcpLiveTests.cs
@@ -7,6 +7,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -110,6 +111,103 @@ await LiveStoreCleanup.RunAsync(cs!, bodySucceeded, async (cleanup, cleanupCt) =
         }
     }
 
+    /// <summary>
+    /// #5562 L4b: the Wait Statistics arm's suffix test moved from <c>right(object_name, 16) = ':Wait Statistics'</c> to
+    /// <c>object_name LIKE '%:Wait Statistics'</c> so a compressed chunk's columnar scan can vectorize it. The two must pick the
+    /// same rows, so this runs the shipped SQL and the same SQL with the old predicate side by side over every object-name shape:
+    /// the default instance, a named instance (with its own isolated spike), another object, a NULL object, and near misses
+    /// (longer and shorter names) that share the suffix's start but not its end.
+    /// </summary>
+    [Fact]
+    public async Task PerfmonTrendSql_LikeSuffixPicksTheSameRowsAsTheOldRightPredicate_AgainstDevPostgres()
+    {
+        var cs = ConnectionString;
+        Assert.SkipWhen(string.IsNullOrEmpty(cs), "Set DARLING_TEST_PG to a Postgres connection string to run the live artifact round trip.");
+
+        var ct = TestContext.Current.CancellationToken;
+        await using var connection = new NpgsqlConnection(cs);
+        await connection.OpenAsync(ct);
+        await PgMigrations.MigrateAsync(connection, ct);
+        await DeleteRowsAsync(connection, ct);
+
+        var bodySucceeded = false;
+        try
+        {
+            await DarlingMcpTestData.RegisterServerAsync(connection, ServerId, ServerName, ct);
+            var t0 = DarlingMcpTestData.TruncateToSeconds(DateTime.UtcNow).AddMinutes(-10);
+
+            var objects = new (string? Name, long[] Values)[]
+            {
+                ("SQLServer:Wait Statistics", new long[] { 300, 310, 320, 330, 340 }),
+                ("MSSQL$INST1:Wait Statistics", new long[] { 200, 214_396_451, 220, 230, 240 }),
+                ("SQLServer:SQL Statistics", new long[] { 11, 12, 13, 14, 15 }),
+                (null, new long[] { 21, 22, 23, 24, 25 }),
+                ("SQLServer:Wait Statistics Extra", new long[] { 31, 32, 33, 34, 35 }),
+                ("Wait Statistics", new long[] { 41, 42, 43, 44, 45 }),
+                ("SQLServer:Wait Statistic", new long[] { 51, 52, 53, 54, 55 }),
+            };
+            foreach (var (name, values) in objects)
+            {
+                for (var i = 0; i < values.Length; i++)
+                {
+                    await DarlingMcpTestData.ExecAsync(connection, ct,
+                        @"INSERT INTO perfmon_stats (collection_id, collection_time, server_id, server_name, object_name, counter_name, instance_name, cntr_value, delta_cntr_value, sample_interval_seconds, cntr_type)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)",
+                        CollectionIdGenerator.Next(), DarlingMcpTestData.Naive(t0.AddMinutes(i)), ServerId, ServerName, name, "Waits started per second", "", values[i],
+                        (long?)null, (int?)null, PerfmonCounterTypes.PerfCounterLargeRawCount);
+                }
+            }
+
+            var shipped = DarlingTrendReader.PerfmonTrendSql;
+            /* Both arms test the suffix with LIKE (the artifact predicate's own right() runs on the first arm's few surviving rows). */
+            Assert.Equal(2, shipped.Split("object_name LIKE '%:Wait Statistics'").Length - 1);
+            var old = shipped.Replace("object_name LIKE '%:Wait Statistics'", "right(object_name, 16) = ':Wait Statistics'", StringComparison.Ordinal);
+            Assert.NotEqual(shipped, old);
+
+            async Task<List<string>> RunAsync(string sql)
+            {
+                var rows = new List<string>();
+                await using var command = new NpgsqlCommand(sql, connection);
+                command.Parameters.AddWithValue(ServerId);
+                command.Parameters.AddWithValue("Waits started per second");
+                command.Parameters.AddWithValue(DarlingMcpTestData.Naive(t0.AddMinutes(-1)));
+                command.Parameters.AddWithValue(DarlingMcpTestData.Naive(t0.AddMinutes(10)));
+                await using var reader = await command.ExecuteReaderAsync(ct);
+                while (await reader.ReadAsync(ct))
+                {
+                    var cells = new string[reader.FieldCount];
+                    for (var c = 0; c < cells.Length; c++)
+                    {
+                        cells[c] = reader.IsDBNull(c) ? "NULL" : Convert.ToString(reader.GetValue(c), System.Globalization.CultureInfo.InvariantCulture)!;
+                    }
+
+                    rows.Add(string.Join("|", cells));
+                }
+
+                return rows;
+            }
+
+            var withLike = await RunAsync(shipped);
+            var withRight = await RunAsync(old);
+            Assert.Equal(5, withLike.Count);
+            Assert.Equal(withRight, withLike);
+
+            /* The named instance's spike is still set aside (the artifact count is the last column), and nothing else is. */
+            Assert.Equal(1, withLike.Sum(r => long.Parse(r.Split('|')[^1], System.Globalization.CultureInfo.InvariantCulture)));
+            bodySucceeded = true;
+        }
+        finally
+        {
+            await LiveStoreCleanup.RunAsync(cs!, bodySucceeded, async (cleanup, cleanupCt) =>
+            {
+                await DeleteRowsAsync(cleanup, cleanupCt);
+                using var servers = new NpgsqlCommand("DELETE FROM servers WHERE server_id = $1", cleanup);
+                servers.Parameters.AddWithValue(ServerId);
+                await servers.ExecuteNonQueryAsync(cleanupCt);
+            });
+        }
+    }
+
     private static Task PlantAsync(NpgsqlConnection connection, System.Threading.CancellationToken ct, DateTime at,
         string counterName, long value, int type) =>
         DarlingMcpTestData.ExecAsync(connection, ct,
diff --git a/Darling/Darling.Tests/WebPageRangeTests.cs b/Darling/Darling.Tests/WebPageRangeTests.cs
index 58b0b44ee3..4aa863c330 100644
--- a/Darling/Darling.Tests/WebPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebPageRangeTests.cs
@@ -84,8 +84,10 @@ public void EveryFinOpsTabPicksItsWindowOnTheRollingOnlyPicker_NotASelect()
     public void TheStorageGrowthPickerTakesTheViewsOwnReachAndWholeDays()
     {
         var src = Js("pages", "finops", "storage-growth.js");
-        Assert.Contains("const STORAGE_GROWTH_REACH_HOURS = 2160;", src);
-        Assert.Contains("reachHours: STORAGE_GROWTH_REACH_HOURS,", src);
+        // #5562 L4b: no reach constant of its own; the picker reads the catalog's view_max_hours for this view.
+        Assert.DoesNotContain("STORAGE_GROWTH_REACH_HOURS", src);
+        Assert.Contains("view: \"storage_growth\",", src);
+        Assert.Contains("view_max_hours", Js("page-range.js"));
         Assert.Contains("minSpanMs: DAY_MS,", src);
         Assert.Contains("stepMs: DAY_MS,", src);
 
diff --git a/Darling/Darling.Tests/WebReadReachLiveTests.cs b/Darling/Darling.Tests/WebReadReachLiveTests.cs
index 6e77c25e80..1bd0fe9029 100644
--- a/Darling/Darling.Tests/WebReadReachLiveTests.cs
+++ b/Darling/Darling.Tests/WebReadReachLiveTests.cs
@@ -131,13 +131,21 @@ await DarlingMcpTestData.ExecAsync(connection, ct,
             Assert.Contains("exceeds maximum of 2160 hours (90 days)",
                 McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, "get_query_store_duration_trend", WebReadReach.RollupTrendHours + 1)));
 
-            /* A read that did not opt in keeps 168: a ranking that routes through the same rollup, and a raw-table trend. */
-            foreach (var read in new[] { "get_top_queries_by_cpu", "get_tempdb_trend", "get_query_heatmap", "get_cpu_utilization" })
+            /* A read that did not opt in keeps 168: a ranking that routes through the same rollup. */
+            foreach (var read in new[] { "get_top_queries_by_cpu" })
             {
                 var refused = McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, read, McpHelpers.MaxHoursBack + 1));
                 Assert.Contains("exceeds maximum of 168 hours (7 days)", refused);
             }
 
+            /* The raw-table trends reach their table's 30 days (#5562 L4b): 720 is answered, 721 is refused, never clamped. */
+            foreach (var read in new[] { "get_tempdb_trend", "get_query_heatmap", "get_cpu_utilization" })
+            {
+                Assert.DoesNotContain("exceeds maximum", await WebReadAsync(postgres, read, WebReadReach.RawTrendHours));
+                var refused = McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, read, WebReadReach.RawTrendHours + 1));
+                Assert.Contains("exceeds maximum of 720 hours (30 days)", refused);
+            }
+
             bodySucceeded = true;
         }
         finally
diff --git a/Darling/Darling.Tests/WebReadReachTests.cs b/Darling/Darling.Tests/WebReadReachTests.cs
index d086a8f0c7..d6a3cf1738 100644
--- a/Darling/Darling.Tests/WebReadReachTests.cs
+++ b/Darling/Darling.Tests/WebReadReachTests.cs
@@ -86,7 +86,10 @@ public void OnlyBucketedTrends_ReachPastTheDefault_AndNoneReachesPastTheirRollup
         {
             if (reach.MaxHours > McpHelpers.MaxHoursBack)
             {
-                Assert.True(reach.Shape == ReadShape.BucketedTrend, $"{read} reaches {reach.MaxHours} h but is a {reach.Shape}; lists and rankings stay at {McpHelpers.MaxHoursBack}.");
+                /* Alert History is the one list that reaches past a week (ruling R8): its reach is the alert table's retention, capped by its row limit. */
+                Assert.True(
+                    reach.Shape == ReadShape.BucketedTrend || read == "get_alert_history",
+                    $"{read} reaches {reach.MaxHours} h but is a {reach.Shape}; lists and rankings stay at {McpHelpers.MaxHoursBack}.");
                 Assert.True(reach.MaxHours <= WebReadReach.RollupTrendHours, $"{read} reaches past the hourly rollup's 90 days.");
             }
             else
@@ -96,9 +99,40 @@ public void OnlyBucketedTrends_ReachPastTheDefault_AndNoneReachesPastTheirRollup
         }
 
         Assert.Equal(
-            new[] { "get_procedure_duration_trend", "get_query_duration_trend", "get_query_store_duration_trend" },
+            new[]
+            {
+                "get_alert_history", "get_blocking_stats", "get_blocking_trend", "get_cpu_utilization", "get_deadlock_trend", "get_file_io_trend",
+                "get_lock_wait_trend", "get_memory_trend", "get_perfmon_trend", "get_pg_cpu_utilization", "get_pg_database_trend", "get_pg_io_trend",
+                "get_procedure_duration_trend", "get_query_duration_trend", "get_query_heatmap", "get_query_store_duration_trend", "get_tempdb_trend",
+                "get_wait_trend",
+            },
             WebReadReach.All.Where(kv => kv.Value.MaxHours > McpHelpers.MaxHoursBack).Select(kv => kv.Key).OrderBy(n => n, StringComparer.Ordinal).ToArray());
         Assert.Equal(2160, WebReadReach.RollupTrendHours);
+        Assert.Equal(720, WebReadReach.RawTrendHours);
+        Assert.Equal(2160, WebReadReach.AlertHistoryHours);
+    }
+
+    /// <summary>
+    /// #5562 L4b, rule 4: a raw-table read never reaches past its table's retention. A read over a table that keeps
+    /// less than 30 days (<c>waiting_tasks</c>, 7) stays at 168; the rollup-routed duration trends are the only reads whose
+    /// reach is the rollup's, not the raw table's, so they are skipped here.
+    /// </summary>
+    [Fact]
+    public void NoRawTableRead_ReachesPastItsCollectorsDefaultRetention()
+    {
+        foreach (var (read, reach) in WebReadReach.All)
+        {
+            if (reach.Collector is null || reach.MaxHours > WebReadReach.RawTrendHours)
+            {
+                continue;
+            }
+
+            Assert.True(
+                CollectorScheduleDefaults.All[reach.Collector].RetentionDays * 24 >= reach.MaxHours,
+                $"{read} reaches {reach.MaxHours} h but its collector {reach.Collector} keeps {CollectorScheduleDefaults.All[reach.Collector].RetentionDays} days.");
+        }
+
+        Assert.Equal(168, WebReadReach.MaxHoursFor("get_current_waits_trend"));
     }
 
     /// <summary>
@@ -127,6 +161,17 @@ public void EveryOptedInValidator_NamesAReadWhoseRowReachesPast168_AndEveryRowTh
             }
         }
 
+        /* A read the MCP deliberately never capped (ValidateUncappedWindow) keeps its validator: the table row only tells the page how far to offer. */
+        var uncapped = new[] { "get_blocking_stats" };
+        var dataTools = System.IO.File.ReadAllText(System.IO.Path.Combine(serviceDir, "Mcp", "DarlingMcpDataTools.cs"));
+        foreach (var read in uncapped)
+        {
+            Assert.True(WebReadReach.All[read].MaxHours > McpHelpers.MaxHoursBack);
+            Assert.DoesNotContain($"MaxHoursFor(\"{read}\")", dataTools);
+            Assert.Matches($@"Name = ""{read}""[\s\S]*?ValidateUncappedWindow", dataTools);
+            optedIn[read] = 1;
+        }
+
         foreach (var read in optedIn.Keys)
         {
             Assert.True(
@@ -164,7 +209,9 @@ public void Catalog_EveryHoursParam_CarriesMaxHoursFromTheTable()
         }
 
         Assert.Equal(2160, HoursParam(catalog, "get_query_store_duration_trend")["max_hours"]!.GetValue<int>());
-        Assert.Equal(168, HoursParam(catalog, "get_wait_trend")["max_hours"]!.GetValue<int>());
+        Assert.Equal(720, HoursParam(catalog, "get_wait_trend")["max_hours"]!.GetValue<int>());
+        Assert.Equal(168, HoursParam(catalog, "get_server_trend")["max_hours"]!.GetValue<int>());
+        Assert.Equal(2160, HoursParam(catalog, "get_alert_history")["max_hours"]!.GetValue<int>());
         Assert.Equal("bucketed_trend", HoursParam(catalog, "get_wait_trend")["shape"]!.GetValue<string>());
         Assert.Equal("latest_snapshot", HoursParam(catalog, "get_active_queries")["shape"]!.GetValue<string>());
     }
diff --git a/Darling/Darling.Tests/alert-history-range-harness.mjs b/Darling/Darling.Tests/alert-history-range-harness.mjs
index 55bcee9832..6971150de9 100644
--- a/Darling/Darling.Tests/alert-history-range-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-range-harness.mjs
@@ -53,6 +53,7 @@ globalThis.fetch = async (url) => {
   urls.push(u);
   let body = {};
   if (u.startsWith("/api/session")) body = { can_edit: true };
+  else if (u.includes("/api/catalog")) body = { reads: [{ name: "get_alert_history", params: [{ name: "hours", collector: null, collector_interval_minutes: null, max_hours: 2160 }] }] };
   else if (u.includes("/list_servers")) body = servers;
   else if (u.includes("/get_alert_history")) body = typeof alertsReply === "function" ? alertsReply(u) : alertsReply;
   return { status: 200, ok: true, text: async () => JSON.stringify(body) };
@@ -102,7 +103,7 @@ try {
       out.windowOptions = pickerItems(main, "Time range").filter((i) => !i.disabled).map((i) => i.name);
       out.windowGreyed = pickerItems(main, "Time range").filter((i) => i.disabled).map((i) => i.name);
       out.windowShape = popupShape(main, "Time range");
-      out.refused = pickRange(main, "Time range", "30d");
+      out.refused = pickRange(main, "Time range", "120d");
       urls.length = 0; pickRange(main, "Time range", "yesterday"); await settle(); out.finished = readsOf().pop();
       urls.length = 0; pickRange(main, "Time range", "30m"); await settle(); out.thirtyMinutes = readsOf().pop();
       out.limitOptions = byLabel(main, "Row limit").children.map((o) => o.attrs.value);
diff --git a/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs b/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
index 81cf475b5b..d1c0f2e52b 100644
--- a/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
+++ b/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
@@ -62,9 +62,14 @@ globalThis.document = withDocumentListeners({
 
 const fetches = [];
 let body = "{}";
+/* The catalog the picker reads its reach from (#5562 L4b): get_finops says 168 for its other views and serves the Storage Growth view's own
+   reach as view_max_hours, the number the server validates. The page takes it from here, not from a constant of its own. */
+const catalogBody = JSON.stringify({
+  reads: [{ name: "get_finops", params: [{ name: "hours", max_hours: 168, view_max_hours: { storage_growth: 2160 } }] }],
+});
 globalThis.fetch = async (url) => {
   fetches.push(String(url));
-  return { status: 200, ok: true, text: async () => body };
+  return { status: 200, ok: true, text: async () => (String(url).includes("/api/catalog") ? catalogBody : body) };
 };
 
 const find = (node, tag) => (node.tag === tag ? node : node.children.map((c) => find(c, tag)).find(Boolean) || null);
diff --git a/Darling/Darling.Tests/page-range-harness.mjs b/Darling/Darling.Tests/page-range-harness.mjs
index 8d6eff562c..31d102a099 100644
--- a/Darling/Darling.Tests/page-range-harness.mjs
+++ b/Darling/Darling.Tests/page-range-harness.mjs
@@ -26,7 +26,7 @@ try {
     reads: [
       { name: "get_wait_trend", params: [{ name: "hours", collector: "wait_stats", collector_interval_minutes: interval, max_hours: 168 }] },
       { name: "get_cpu_utilization", params: [{ name: "hours", collector: "cpu_utilization", collector_interval_minutes: 1, max_hours: 168 }] },
-      { name: "get_alert_history", params: [{ name: "hours", collector: null, collector_interval_minutes: null, max_hours: 168 }] },
+      { name: "get_alert_history", params: [{ name: "hours", collector: null, collector_interval_minutes: null, max_hours: 2160 }] },
     ],
   });
   const out = {};
diff --git a/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs b/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
index 3ae8dae16c..06b3b60960 100644
--- a/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/DarlingWebEndpoints.cs
@@ -4736,6 +4736,17 @@ private static void AddReach(JsonObject param, string read, int? serverId, IRead
         };
         var collector = reach?.Collector;
         param["max_hours"] = reach?.MaxHours ?? WebReadReach.DefaultHours;
+        if (WebReadReach.ViewMaxHours.TryGetValue(read, out var views))
+        {
+            var viewReach = new JsonObject();
+            foreach (var (view, hours) in views)
+            {
+                viewReach[view] = hours;
+            }
+
+            param["view_max_hours"] = viewReach;
+        }
+
         param["shape"] = shape;
         param["collector"] = collector;
         param["collector_interval_minutes"] = WebReadReach.CollectorIntervalMinutes(collector, serverId, schedules);
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
index 1f36a2938e..94e5d09aa2 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
@@ -80,7 +80,7 @@ public sealed class DarlingMcpAlertTools
     public static async Task<string> GetAlertHistory(
         NpgsqlDataSource postgres,
         [Description("Server name or display name. Omit to return alerts across all servers (the fleet default).")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 2160 (90 days, the alert table's retention).")] int hours_back = 24,
         [Description("Maximum rows to return, newest first. Default 50. This is what bounds the page — read truncated to know whether the window held more.")] int limit = 50,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         /* Appended after as_of for the reason get_collection_log's filters are: MCP invokes by name, the
@@ -89,7 +89,8 @@ positional C# caller can be re-bound by. */
         [Description("Include alerts an operator has dismissed in the Viewer. Default false, which is the Alert History grid's own read.")] bool include_dismissed = false,
         CancellationToken cancellationToken = default)
     {
-        var hoursError = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562 ruling R8: the alert table keeps 90 days and the read is capped by its row limit (DarlingAlertReader LIMIT), so it reaches the retention. */
+        var hoursError = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_alert_history"), out var windowEnd);
         if (hoursError != null) return hoursError;
         var limitError = McpHelpers.ValidateTop(limit);
         if (limitError != null) return limitError;
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs
index a2095c31d9..a221d9fcd8 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs
@@ -804,7 +804,7 @@ XML in the window than limit". */
     public static Task<string> GetBlockingTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
         CancellationToken cancellationToken = default) =>
@@ -823,7 +823,8 @@ internal static async Task<string> GetBlockingTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 33.6 ms at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_blocking_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         try
@@ -878,14 +879,15 @@ means nothing at all is known about the window. The stored tables cannot tell th
     public static async Task<string> GetDeadlockTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         CancellationToken cancellationToken = default)
     {
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 13.8 ms at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_deadlock_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         try
@@ -931,7 +933,7 @@ where it modifies the collector rather than the event. */
     public static Task<string> GetLockWaitTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -949,7 +951,8 @@ internal static async Task<string> GetLockWaitTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 5.3 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_lock_wait_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs
index edf2233d22..09079bfcc5 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs
@@ -60,7 +60,7 @@ public sealed class DarlingMcpDataTools
     public static Task<string> GetCpuUtilization(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 4.")] int hours_back = 4,
+        [Description("Hours of history. Default 4; up to 720 (30 days).")] int hours_back = 4,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -79,7 +79,8 @@ internal static async Task<string> GetCpuUtilization(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 0.62 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_cpu_utilization"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
@@ -241,7 +242,7 @@ public static Task<string> GetWaitTrend(
         NpgsqlDataSource postgres,
         [Description("The exact wait type name, e.g. CXPACKET, PAGEIOLATCH_SH.")] string wait_type,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -256,7 +257,8 @@ internal static async Task<string> GetWaitTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 0.70 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_wait_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
@@ -527,7 +529,7 @@ itself is a pre-V127 row that never recorded one. */
     public static Task<string> GetTempDbTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -542,7 +544,8 @@ internal static async Task<string> GetTempDbTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 0.90 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_tempdb_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
index 9b1211d56d..0e3faf07c7 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
@@ -48,7 +48,7 @@ public sealed class DarlingMcpPgCpuUtilizationTools
     public static Task<string> GetPgCpuUtilization(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 4.")] int hours_back = 4,
+        [Description("Hours of history. Default 4; up to 720 (30 days).")] int hours_back = 4,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         ILogger? logger = null,
@@ -66,7 +66,8 @@ internal static async Task<string> GetPgCpuUtilization(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 65 ms at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_pg_cpu_utilization"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
index 10f5961293..019ea4f05c 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
@@ -261,7 +261,7 @@ public static Task<string> GetPgIoTrend(
         [Description("Server name or display name.")] string? server_name = null,
         [Description("Which backend did the I/O, e.g. 'client backend', 'autovacuum worker', 'checkpointer'.")] string? backend_type = null,
         [Description("Why the I/O happened: normal, bulkread, bulkwrite, vacuum, index, walreplay. Naming this alone follows the busiest BACKEND in that context; omit both to follow whichever pair moved the most I/O.")] string? context = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -280,7 +280,8 @@ internal static async Task<string> GetPgIoTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 7.4 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_pg_io_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
@@ -523,7 +524,7 @@ public static Task<string> GetPgDatabaseTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
         [Description("The database to follow. Pass '(shared relations)' for PostgreSQL's cluster-wide catalog row. Omit to follow the biggest temp-file spiller in the window.")] string? database = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -542,7 +543,8 @@ internal static async Task<string> GetPgDatabaseTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 2.3 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_pg_database_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs
index 70117d2a45..ec9c33e132 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs
@@ -62,7 +62,7 @@ public sealed class DarlingMcpQueryHeatmapTools
     public static Task<string> GetQueryHeatmap(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("How far back to look, in hours. Default 24.")] int hours_back = 24,
+        [Description("How far back to look, in hours. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description("Which per-execution metric to bucket by: duration, cpu, logical_reads, logical_writes or execution_count. Default duration.")] string? metric = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
         [Description("Width of each time bin, in minutes. Default 5 - the desktop viewer's own bin width, so the two surfaces agree. Raise it to cover a longer window in fewer cells.")] int bucket_minutes = DarlingQueryHeatmapReader.ViewerBucketMinutes,
@@ -98,7 +98,8 @@ internal static async Task<string> GetQueryHeatmap(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd)
+        /* #5562: reaches the raw table's 30-day retention (720 h); 5.5 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_query_heatmap"), out var windowEnd)
             ?? McpHelpers.ValidateTop(limit);
         if (validation != null) return validation;
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
index 47534df942..76d91e5253 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
@@ -98,7 +98,7 @@ public sealed class DarlingMcpTrendTools
     public static Task<string> GetMemoryTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -114,7 +114,8 @@ internal static async Task<string> GetMemoryTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 0.86 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_memory_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
@@ -171,7 +172,7 @@ public static Task<string> GetPerfmonTrend(
         NpgsqlDataSource postgres,
         [Description("The exact counter name, e.g. 'Batch Requests/sec'.")] string counter_name,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -186,7 +187,9 @@ internal static async Task<string> GetPerfmonTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h). The 12.5 s at 30 days came from the Wait Statistics arm's right(object_name, 16) filter, which
+           decompressed and dropped every row; DarlingTrendReader.PerfmonTrendSql now filters with LIKE, which the columnar scan vectorizes. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_perfmon_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);
@@ -270,7 +273,7 @@ deltas and the seconds they accrued over (#3960), so that division still holds p
     public static Task<string> GetFileIoTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24.")] int hours_back = 24,
+        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         [Description("One database, charted per file. Omit for every database.")] string? database_name = null,
@@ -300,7 +303,8 @@ internal static async Task<string> GetFileIoTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
+        /* #5562: reaches the raw table's 30-day retention (720 h); 6.3 s at 30 days on a large store. The ceiling is the WebReadReach row. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_file_io_trend"), out var windowEnd);
         if (validation != null) return validation;
 
         /* An unusable width is a fault in the request whatever the window holds, so it is refused before anything
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingTrendReader.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingTrendReader.cs
index 665e9ab20c..62ce784269 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingTrendReader.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingTrendReader.cs
@@ -389,7 +389,13 @@ private static string BuildPerfmonTrendSql()
     {
         var isArtifact = "COALESCE((" + WaitStatisticsArtifact.ArtifactPredicateSql(
             "cntr_type", "object_name", "prev_value", "cntr_value", "next_value") + "), false)";
-        var isWaitStatistics = WaitStatisticsArtifact.ObjectNameSuffixMatchSql("object_name");
+        /* #5562 L4b: the suffix test as LIKE, not right(object_name, 16) = '...'. On a compressed perfmon_stats chunk the right()
+           call is a plain Filter, so the first arm (which returns nothing for any counter outside the Wait Statistics object)
+           decompressed and materialized every row of the counter in the window and threw them all away: 12.5 s for 30 days of
+           Batch Requests/sec on a large store. LIKE runs inside the columnar scan's Vectorized Filter. Same rows: the suffix has no
+           wildcard character, and NULL still lands in the second arm only. The shared WaitStatisticsArtifact text (Lite and the
+           Viewer) is left as it is. */
+        var isWaitStatistics = $"object_name IS NOT NULL AND object_name LIKE '%{WaitStatisticsArtifact.ObjectNameSuffix}'";
         return $$"""
             SELECT
                 collection_time,
diff --git a/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
index df1914735f..4e59caa35e 100644
--- a/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
@@ -10,6 +10,7 @@
 using System.Collections.Generic;
 using PerformanceMonitor.Collectors;
 using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Storage;
 
 namespace PerformanceMonitor.Darling.Service;
 
@@ -55,9 +56,11 @@ internal sealed record ReadReach(ReadShape Shape, int MaxHours, string? Collecto
 /// <see cref="McpHelpers.MaxHoursBack"/> even where they route through a rollup (a top-N over 90 days is a different
 /// payload, and the MCP ceiling rises for bucketed trends only); query text and plans are kept for a few days only
 /// (<c>RetentionTierRouter.ClampToTextHorizon</c>), and none of the three opted-in reads carries either.
-/// The raw-table bucketed trends (waits, CPU, memory, file I/O, tempdb, perfmon, blocking) stay at 168 hours in code
-/// until a timing run on a large store says a month is affordable; raising one is a one-line change to its row here,
-/// plus its validator call, and nothing else.</para>
+/// The raw-table bucketed trends reach <see cref="RawTrendHours"/> (30 days, the raw tables' default retention) once a
+/// timing run on a large store measured a month under 10 seconds (#5562 L4b); a trend not yet timed, or over a table
+/// that keeps less than 30 days, stays at 168 hours. Raising one is a one-line change to its row here, plus its
+/// validator call, and nothing else. Alert History is the one list that reaches past a week (ruling R8): its reach is
+/// the alert table's retention, <see cref="AlertHistoryHours"/>, and the read is capped by its row limit.</para>
 /// </summary>
 internal static class WebReadReach
 {
@@ -68,8 +71,32 @@ internal static class WebReadReach
     /// <c>ComposeLimits.MaxWindowHours</c>).</summary>
     public const int RollupTrendHours = 24 * 90;
 
+    /// <summary>The raw-table trends' reach: 30 days (#5562 L4b), what every raw collector table keeps by default.
+    /// A read over a table with a shorter retention (<c>waiting_tasks</c> keeps 7 days) stays at
+    /// <see cref="DefaultHours"/>, and a read that spans tables takes the shortest.</summary>
+    public const int RawTrendHours = 24 * DarlingRetentionHorizons.DataRetentionBaseDays;
+
+    /// <summary>Alert History's reach: the alert table's retention, 90 days (#5562 ruling R8), the longest choice the
+    /// Viewer already offers (<see cref="DarlingRetentionHorizons.AlertHistoryRetentionDays"/>).</summary>
+    public const int AlertHistoryHours = 24 * DarlingRetentionHorizons.AlertHistoryRetentionDays;
+
+    /// <summary>
+    /// A view of one read that reaches further than the read's own row (#5562 L4b): <c>get_finops</c> serves its other views
+    /// at <see cref="DefaultHours"/>, but its Storage Growth view takes up to 90 days of whole days, validated by
+    /// <see cref="Mcp.DarlingMcpFinOpsTools.MaxStorageGrowthHoursBack"/>. The catalog serves this as <c>view_max_hours</c> on the
+    /// read's <c>hours</c> param, and the page reads it from there, so the page, the catalog and the server share one number.
+    /// </summary>
+    public static readonly IReadOnlyDictionary<string, IReadOnlyDictionary<string, int>> ViewMaxHours =
+        new Dictionary<string, IReadOnlyDictionary<string, int>>(StringComparer.Ordinal)
+        {
+            ["get_finops"] = new Dictionary<string, int>(StringComparer.Ordinal)
+            {
+                ["storage_growth"] = Mcp.DarlingMcpFinOpsTools.MaxStorageGrowthHoursBack,
+            },
+        };
+
     private static ReadReach Trend(string? collector, int maxHours = DefaultHours) => new(ReadShape.BucketedTrend, maxHours, collector);
-    private static ReadReach List(string? collector) => new(ReadShape.List, DefaultHours, collector);
+    private static ReadReach List(string? collector, int maxHours = DefaultHours) => new(ReadShape.List, maxHours, collector);
     private static ReadReach Snapshot(string? collector) => new(ReadShape.LatestSnapshot, DefaultHours, collector);
 
     /// <summary>Every windowed read (one with an <c>hours</c> parameter in the web catalog), by read name.</summary>
@@ -80,25 +107,28 @@ internal static class WebReadReach
         ["get_procedure_duration_trend"] = Trend("procedure_stats", RollupTrendHours),
         ["get_query_store_duration_trend"] = Trend("query_store", RollupTrendHours),
 
-        /* Raw-table bucketed trends: 168 hours until the large-store timing run (item 4 of #5562's L4 lane). */
-        ["get_blocking_trend"] = Trend("blocked_process_report"),
-        ["get_deadlock_trend"] = Trend("deadlocks"),
-        ["get_lock_wait_trend"] = Trend("wait_stats"),
+        /* Raw-table bucketed trends: 720 hours where the large-store timing run measured a month under 10 s (#5562 L4b;
+           each validator names its time). Left at 168: get_current_waits_trend (its waiting_tasks table keeps 7 days),
+           get_server_trend (6 of its 11 metrics were never timed), get_pg_wait_trend (its timing table was empty) and
+           get_pg_query_duration_trend (not timed). get_blocking_stats is uncapped on the MCP side (ValidateUncappedWindow). */
+        ["get_blocking_trend"] = Trend("blocked_process_report", RawTrendHours),
+        ["get_deadlock_trend"] = Trend("deadlocks", RawTrendHours),
+        ["get_lock_wait_trend"] = Trend("wait_stats", RawTrendHours),
         ["get_current_waits_trend"] = Trend("waiting_tasks"),
-        ["get_blocking_stats"] = Trend("dmv_blocking_snapshot"),
-        ["get_cpu_utilization"] = Trend("cpu_utilization"),
-        ["get_query_heatmap"] = Trend("query_stats"),
-        ["get_tempdb_trend"] = Trend("tempdb_stats"),
-        ["get_wait_trend"] = Trend("wait_stats"),
-        ["get_file_io_trend"] = Trend("file_io_stats"),
-        ["get_memory_trend"] = Trend("memory_stats"),
+        ["get_blocking_stats"] = Trend("dmv_blocking_snapshot", RawTrendHours),
+        ["get_cpu_utilization"] = Trend("cpu_utilization", RawTrendHours),
+        ["get_query_heatmap"] = Trend("query_stats", RawTrendHours),
+        ["get_tempdb_trend"] = Trend("tempdb_stats", RawTrendHours),
+        ["get_wait_trend"] = Trend("wait_stats", RawTrendHours),
+        ["get_file_io_trend"] = Trend("file_io_stats", RawTrendHours),
+        ["get_memory_trend"] = Trend("memory_stats", RawTrendHours),
         ["get_server_trend"] = Trend(null),
-        ["get_perfmon_trend"] = Trend("perfmon_stats"),
-        ["get_pg_cpu_utilization"] = Trend("pg_cpu_utilization"),
+        ["get_perfmon_trend"] = Trend("perfmon_stats", RawTrendHours),
+        ["get_pg_cpu_utilization"] = Trend("pg_cpu_utilization", RawTrendHours),
         ["get_pg_wait_trend"] = Trend("pg_wait_sampling"),
         ["get_pg_query_duration_trend"] = Trend("pg_statement_stats"),
-        ["get_pg_io_trend"] = Trend("pg_io_stats"),
-        ["get_pg_database_trend"] = Trend("pg_database_stats"),
+        ["get_pg_io_trend"] = Trend("pg_io_stats", RawTrendHours),
+        ["get_pg_database_trend"] = Trend("pg_database_stats", RawTrendHours),
 
         /* Lists, rankings and unbucketed series. */
         ["get_top_queries_by_cpu"] = List("query_stats"),
@@ -174,7 +204,7 @@ internal static class WebReadReach
         ["compare_analysis"] = List(null),
         ["get_analysis_facts"] = List(null),
         ["get_analysis_findings"] = List(null),
-        ["get_alert_history"] = List(null),
+        ["get_alert_history"] = List(null, AlertHistoryHours),
         ["get_fleet_overview"] = List(null),
         ["get_sweep_reports"] = List(null),
         ["get_store_log"] = List(null),
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
index 6ccd8b2802..d0e021f70f 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
@@ -72,7 +72,9 @@ export function collectorIntervalFromCatalog(catalog, collector) {
  *
  * @param {object} opts
  * @param {string} opts.read the catalog read the page calls (its `hours` param carries the reach and the collector's interval)
- * @param {number} [opts.reachHours] a reach the page knows better than the read-level catalog (a view of get_finops that reaches further)
+ * @param {number} [opts.reachHours] a reach the page knows better than the catalog; prefer `opts.view`, which reads it from the catalog
+ * @param {string} [opts.view] a view of the read that reaches further than the read does (get_finops storage_growth): its reach is the
+ *   catalog's `view_max_hours[view]`, the number the server validates
  * @param {string} [opts.server] ask the catalog for this server's own collector interval
  * @param {boolean} [opts.useCatalogInterval] default true; false for a read that no collector feeds
  */
@@ -81,7 +83,8 @@ export function pageRangePicker(opts) {
   const ready = (async () => {
     try {
       const entry = await catalogEntryFor(opts.read);
-      picker.setReach(opts.reachHours > 0 ? opts.reachHours : reachHours(entry));
+      const viewMax = opts.view && entry && entry.params ? Number((hoursParam(entry).view_max_hours || {})[opts.view]) : NaN;
+      picker.setReach(viewMax > 0 ? viewMax : opts.reachHours > 0 ? opts.reachHours : reachHours(entry));
       if (opts.useCatalogInterval === false) return;
       if (opts.server) {
         const interval = collectorIntervalFromCatalog(await serverCatalog(opts.server), entry && entry.params ? hoursParam(entry).collector : null);
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
index 7e3c2bd2eb..686d65321c 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
@@ -412,10 +412,9 @@ function reconcileRows(tbody, rows, rowMap) {
 
 /* The four read choices, kept at module scope so the 60 s poll (which calls renderAlerts again) and a visit to
  * another page and back keep them. The range is the shared time range picker's spec (#5562), read as of each read so a
- * rolling range slides. The picker takes the reach from the catalog (get_alert_history reaches 168 hours), so a longer
- * range is greyed out with the reason, never clamped, and there is no All. The alert table itself keeps 90 days
- * (DarlingRetention.AlertHistoryRetentionDays, R8), but the web read stops at the common 7 day reach (R2). The row limits
- * stop at the dispatch layer's 1000-row ceiling. The server is the registry's server_name ("" = the whole fleet). */
+ * rolling range slides. The picker takes the reach from the catalog (get_alert_history reaches 2160 hours, 90 days: the
+ * alert table's retention, DarlingRetention.AlertHistoryRetentionDays, ruling R8, #5562 L4b), so a longer range is greyed
+ * out with the reason, never clamped, and there is no All. The row limits stop at the dispatch layer's 1000-row ceiling. The server is the registry's server_name ("" = the whole fleet). */
 const DEFAULT_HOURS = 24;
 const LIMIT_CHOICES = [200, 500, 1000];
 const choices = { spec: relativeSpec(DEFAULT_HOURS * 3600000), limit: 200, server: "", dismissed: false };
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
index 37b1eb5ba6..3435ed4fc7 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
@@ -24,10 +24,10 @@ const OBJECT_LIMIT = 20;
 const DATABASE_LIMIT = 500;
 
 // The objects window, in whole days (the heatmap has one column per day). The service reads it as hours_back (days * 24) and takes up to
-// 2160 hours for this view (DarlingMcpFinOpsTools.cs: "storage_growth: max 2160"), though the get_finops catalog entry says 168 for its
-// other views, so the picker is given this view's own reach. 30 days is the default.
+// 2160 hours for this view (DarlingMcpFinOpsTools.MaxStorageGrowthHoursBack), though the get_finops catalog entry says 168 for its
+// other views. The catalog serves this view's own reach as `view_max_hours.storage_growth` (WebReadReach.ViewMaxHours, #5562 L4b), the
+// number the server validates, and the picker reads it from there. 30 days is the default.
 const DAY_MS = 86400000;
-const STORAGE_GROWTH_REACH_HOURS = 2160;
 const DEFAULT_DAYS = 30;
 
 // The drill per server: { level, database, object, days }. It lives at module scope because the page's 60 s poll calls build()
@@ -194,7 +194,7 @@ export const tab = {
     function windowPicker() {
       return finopsWindowControl({
         hours: state.days * 24,
-        reachHours: STORAGE_GROWTH_REACH_HOURS,
+        view: "storage_growth",
         minSpanMs: DAY_MS,
         stepMs: DAY_MS,
         onChange: (hours) => {
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
index 7ddac64bc3..fca7537238 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
@@ -21,7 +21,8 @@ const HOUR_MS = 3600000;
  * @param {object} opts
  * @param {number} opts.hours the window to start on, in whole hours
  * @param {(hours: number) => void} opts.onChange raised with the whole hours the reader picked
- * @param {number} [opts.reachHours] the view's own reach, when it is longer than the read's catalog reach
+ * @param {number} [opts.reachHours] a fixed reach for the view; prefer `opts.view`
+ * @param {string} [opts.view] the get_finops view whose own reach (catalog `view_max_hours`) is longer than the read's `max_hours`
  * @param {number} [opts.minSpanMs] a floor above one hour (a daily read)
  * @param {number} [opts.stepMs] the unit a length must be a whole number of (default one hour)
  * @param {string} [opts.label] the control's label (default "Window")
@@ -38,6 +39,7 @@ export function finopsWindowControl(opts) {
     minSpanMs: opts.minSpanMs || ROLLING_ONLY_MIN_SPAN_MS,
     stepMs: opts.stepMs,
     reachHours: opts.reachHours,
+    view: opts.view,
     /* No collector feeds the FinOps views as one read, so there is no "collected every N minutes" note here. */
     useCatalogInterval: false,
     onChange: () => opts.onChange(currentHours()),

From f190aaa81d5bcb30c2e62709dad0cf71dc6f3f0e Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 12:43:36 -0400
Subject: [PATCH 20/33] Desktop round-1 fixes for the shared time range picker
 (#5562)

H1: an id or legacy-hours value past the 100-year limit no longer overflows TimeSpan (startup/tab crash from a corrupt settings file).
M1: Lite Alert History, Job History and FinOps pickers read typed times and calendar periods in the zone their grid uses.
M2: Apply to All resolves a calendar period once (ForBroadcast now lives in PerformanceMonitor.Ui, used by Lite and the Viewer).
M3/L1 (R8): Job History "Last Year" (365d) on both desktops; Lite Alert History "All" is 365d.
L2: Lite clears probed data-start floors when the range moves.
L3: the Viewer's sample-interval note follows the sub-tab on screen and updates inside the reload loop.
L4: removed the unreachable AtLeastMinimumSpan.
L5 (ruling): calendar periods are exempt from the 5-minute floor.
L6: behaviour tests for H1 and M1; dropped two text pins that duplicate live tests.
Guard: stacked summaries, CommentFilterAdoption and KnownTruncatedRanges pins.
---
 .../CommentFilterAdoptionTests.cs             | 11 ++-
 .../Fixtures/time-range-cases.json            | 10 +--
 .../TimeRangePickerControlTests.cs            |  7 +-
 Darling/Darling.Tests/TimeRangeTests.cs       | 46 +++++++++-
 .../Darling.Tests/TsqlConventionGuardTests.cs |  5 ++
 .../ViewerTimeRangeGapFixTests.cs             | 12 ---
 .../ViewerTimeRangeWindowTests.cs             | 56 ++++++++++--
 .../JobHistoryTab.xaml                        |  2 +-
 .../JobHistoryTab.xaml.cs                     |  2 +
 .../ViewerServerTab.TimeRange.cs              | 44 +++++++++-
 .../ViewerServerTab.xaml.cs                   |  6 +-
 .../ViewerTimeRangeWindow.cs                  | 67 ++++++++++----
 Lite.Tests/LiteTimeRangeGapTests.cs           | 87 ++++++++++++++-----
 Lite.Tests/ServerTabHeldRangeTests.cs         | 23 ++---
 Lite/Controls/AlertsHistoryTab.xaml.cs        |  9 +-
 .../CorrelatedTimelineLanesControl.xaml.cs    |  6 +-
 Lite/Controls/JobHistoryTab.xaml.cs           | 47 +++++++++-
 Lite/Controls/ServerTab.DrillDown.cs          |  5 +-
 Lite/Controls/ServerTab.TimeRange.cs          | 21 +++--
 Lite/Helpers/LiteTimeRange.cs                 | 38 +++-----
 Lite/Services/ServerTimeHelper.cs             |  7 ++
 .../TimeRange/TimeRangePresets.cs             | 21 ++++-
 .../TimeRange/TimeRangeSpec.cs                | 31 ++++---
 23 files changed, 427 insertions(+), 136 deletions(-)

diff --git a/Darling/Darling.Tests/CommentFilterAdoptionTests.cs b/Darling/Darling.Tests/CommentFilterAdoptionTests.cs
index 8d4e58c7ea..d96e28c258 100644
--- a/Darling/Darling.Tests/CommentFilterAdoptionTests.cs
+++ b/Darling/Darling.Tests/CommentFilterAdoptionTests.cs
@@ -85,7 +85,7 @@ public sealed class CommentFilterAdoptionTests
     /// name a new entry.
     ///
     /// <para>Four kinds live here and they are not the same kind. Eight <b>collect</b> a doc-comment run,
-    /// where the prefix is what defines the run. Two read a <b>stated, measured</b> bound off a named file each.
+    /// where the prefix is what defines the run. Three read a <b>stated, measured</b> bound off a named file each.
     /// One filters <b>SQL</b>, which the C# walk cannot help with. One <b>demonstrates</b> the shape on an
     /// arranged fixture, which is this file.</para>
     /// </summary>
@@ -168,6 +168,15 @@ public sealed class CommentFilterAdoptionTests
             + "which is a pass for the wrong reason. Measurement-dependent, not permanent: a second block "
             + "comment in that file makes the bound wrong.",
 
+        ["Lite.Tests/LiteTimeRangeGapTests.cs"] =
+            "STATED BOUND, measured. It COUNTS call sites of ApplyWindowFloorToBanner( across Lite's tab sources (#5562 R7: every banner site feeds the "
+            + "picker's data start). IsDocOrDefinition drops a match whose line, trimmed, starts with //, ///, * or /*, so a "
+            + "doc or comment mention is not a site, and drops the method's own definition line. Stated bound: it reads one "
+            + "line, so a call written inside a block comment on a line that does not begin with * or /* is miscounted as a "
+            + "site (a spurious extra site, the loud direction: the per-file count then disagrees with the sites pinned). "
+            + "The walker would drop the call as comment text correctly, but the same test also needs the definition line "
+            + "kept apart, which the line check does in one step; the sources it reads carry no such block comment today.",
+
         ["Darling.Tests/Pg18IoBytesTests.cs"] =
             "NOT C#. The filter runs over DarlingPgIoReader.PgIoSql - SQL text already extracted from a raw "
             + "string literal - and drops SQL block-comment lines from the outer SELECT list before counting "
diff --git a/Darling/Darling.Tests/Fixtures/time-range-cases.json b/Darling/Darling.Tests/Fixtures/time-range-cases.json
index 1b51a1e519..491bccb33d 100644
--- a/Darling/Darling.Tests/Fixtures/time-range-cases.json
+++ b/Darling/Darling.Tests/Fixtures/time-range-cases.json
@@ -971,11 +971,11 @@
    "input": "today",
    "now": "2026-10-08T04:02:00Z",
    "zone": "America/New_York",
-   "start": null,
-   "end": null,
-   "live": null,
-   "echo": null,
-   "error": "too_short"
+   "start": "2026-10-08T04:00:00Z",
+   "end": "2026-10-08T04:02:00Z",
+   "live": true,
+   "echo": "2m  Oct 8, 12:00 am - Oct 8, 12:02 am (UTC-04:00)",
+   "error": null
   },
   {
    "name": "end before start",
diff --git a/Darling/Darling.Tests/TimeRangePickerControlTests.cs b/Darling/Darling.Tests/TimeRangePickerControlTests.cs
index 85d6a46351..d08cc05168 100644
--- a/Darling/Darling.Tests/TimeRangePickerControlTests.cs
+++ b/Darling/Darling.Tests/TimeRangePickerControlTests.cs
@@ -74,9 +74,14 @@ public void Select_RefusesARangeUnderTheMinimum_AndHoldsTheOldOne()
             var raised = false;
             picker.RangeChanged += (_, _) => raised = true;
 
-            Assert.False(picker.Select(TimeRangeSpec.ForPeriod(CalendarPeriod.Today)));
+            Assert.False(picker.Select(TimeRangeSpec.Relative(TimeSpan.FromMinutes(4))));
             Assert.False(raised);
             Assert.Equal("4h", picker.Value.Id);
+
+            /* A calendar period is exempt from the floor: Today at 00:02 is held, never replaced by another range. */
+            Assert.True(picker.Select(TimeRangeSpec.ForPeriod(CalendarPeriod.Today)));
+            Assert.True(raised);
+            Assert.Equal("today", picker.Value.Id);
         });
     }
 
diff --git a/Darling/Darling.Tests/TimeRangeTests.cs b/Darling/Darling.Tests/TimeRangeTests.cs
index c329f21dd6..694314382f 100644
--- a/Darling/Darling.Tests/TimeRangeTests.cs
+++ b/Darling/Darling.Tests/TimeRangeTests.cs
@@ -115,8 +115,50 @@ public void CalendarPeriods_ReportTheirCurrentLength()
         Assert.Equal("7d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousWeek), Now, NewYork));
         Assert.Equal("30d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousMonth), Now, NewYork));
         Assert.Equal("365d", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.PreviousYear), Now, NewYork));
-        // Just after midnight Today is under the minimum, so it has no length to show.
-        Assert.Null(TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), new DateTime(2026, 10, 8, 4, 2, 0), NewYork));
+        // Just after midnight Today is exempt from the 5-minute floor (seat ruling): it reads 00:00 to now, never another range.
+        Assert.Equal("2m", TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), new DateTime(2026, 10, 8, 4, 2, 0), NewYork));
+        // Exactly at midnight nothing has happened yet, so a zero-length period is still refused.
+        Assert.Null(TimeRangePresets.CurrentLength(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), new DateTime(2026, 10, 8, 4, 0, 0), NewYork));
+    }
+
+    [Theory]
+    [InlineData("400000mo")]
+    [InlineData("1000000d")]
+    [InlineData("999999w")]
+    [InlineData("1000000h")]
+    public void AnId_PastTheHundredYearLimit_IsNotAnIdAndNeverThrows(string id)
+    {
+        // #5562 review H1: a hand-edited settings value used to overflow TimeSpan and crash startup.
+        Assert.False(TimeRangeSpec.TryFromId(id, out var spec));
+        Assert.Null(spec);
+    }
+
+    [Fact]
+    public void AnId_AtTheLimit_StillParses()
+    {
+        Assert.True(TimeRangeSpec.TryFromId("36500d", out var spec));
+        Assert.Equal(TimeSpan.FromDays(36500), spec!.Span);
+        Assert.False(TimeRangeSpec.TryFromId("36501d", out _));
+    }
+
+    [Theory]
+    [InlineData(int.MaxValue)]
+    [InlineData(300_000_000)]
+    [InlineData(876_001)]
+    public void LegacyHours_PastTheLimit_AreNull_NotAnOverflow(int hours)
+    {
+        Assert.Null(TimeRangePresets.FromLegacyHours(hours));
+    }
+
+    [Fact]
+    public void ACalendarPeriodIsExemptFromTheFloor_ButARelativeOrFixedRangeIsNot()
+    {
+        var justAfterMidnight = new DateTime(2026, 10, 8, 4, 2, 0);
+        Assert.True(TimeRangeSpec.ForPeriod(CalendarPeriod.Today).TryResolve(justAfterMidnight, NewYork, out var today, out _));
+        Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), today!.StartUtc);
+        Assert.Equal(justAfterMidnight, today.EndUtc);
+        Assert.False(TimeRangeSpec.FixedRange(justAfterMidnight.AddMinutes(-2), justAfterMidnight).TryResolve(justAfterMidnight, NewYork, out _, out var error));
+        Assert.Equal("too_short", error!.Code);
     }
 
     [Fact]
diff --git a/Darling/Darling.Tests/TsqlConventionGuardTests.cs b/Darling/Darling.Tests/TsqlConventionGuardTests.cs
index 2c1061b3b2..842dcf18aa 100644
--- a/Darling/Darling.Tests/TsqlConventionGuardTests.cs
+++ b/Darling/Darling.Tests/TsqlConventionGuardTests.cs
@@ -1543,6 +1543,11 @@ Lite twin (LocalDataService.FinOps.IndexObjects.cs, below) derives the same four
            newest > TimeSpan.FromDays(ArchiveService.HotDataDays)`, an age comparison on the newest snapshot
            time, not T-SQL and not a tempdb label, so no census reads a site of that kind here. */
         "Lite/Services/LocalDataService.DatabaseStates.cs IsStale",
+        /* #5562: an expression-bodied method whose body opens with a property pattern (`untilUtc is { } end ? … : …`), the
+           same shape as IsStale above. The brace match closes the range at the pattern's own `}`, stranding the two calls to
+           ReadAlertHistoryAsync. They hold no string literal and no T-SQL (the SQL is in ReadAlertHistoryAsync, which the scan
+           reads whole), so no census reads a site of that kind outside the range. */
+        "Lite/Services/LocalDataService.AlertHistory.cs GetAlertHistoryWindowAsync",
         /* #3541 A12: the Lite twin of the four DarlingObjectStatsReader growth derivations above — the same
            `is { } b ? … : null` shape, the same absence of any string literal. */
         "Lite/Services/LocalDataService.FinOps.IndexObjects.cs DailyGrowthRateMb",
diff --git a/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs b/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
index 9e3a1a50a5..f9f02aeb2f 100644
--- a/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
+++ b/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
@@ -256,18 +256,6 @@ public void ThePickersLongestChoice_IsOneMoreButton_ThatSelectsItsSpan()
 
     // ── R6: Job History's end bound, applied before the row cap ──
 
-    [Fact]
-    public void TheJobHistoryTab_HandsAFinishedRangesEndToTheRead_AndNoLongerTrimsOnTheClient()
-    {
-        var tab = Code("JobHistoryTab.xaml.cs");
-        Assert.Matches(@"GetJobHistoryAsync\(sinceUtc,\s*serverId,\s*RowCap,\s*untilUtc:\s*windowIsLive \? null : windowEndUtc\)", tab);
-        Assert.DoesNotContain("windowEndUtc).ToList()", tab, StringComparison.Ordinal);
-        Assert.DoesNotContain("ran < windowEndUtc", tab, StringComparison.Ordinal);
-
-        var read = ViewerTypedRangeTests.StripComments(ViewerTypedRangeTests.MemberText(ViewerFile("ViewerDataService.JobHistory.cs"), "GetJobHistoryAsync"));
-        Assert.Contains("new JobHistoryFilter(UntilUtc: until.AddTicks(-TimeSpan.TicksPerMicrosecond))", read, StringComparison.Ordinal);
-    }
-
     private const int EndBoundServer = -556_201;
     private const long EndBoundIdBase = 5_562_000_000L;
 
diff --git a/Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs b/Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs
index 058d1c2083..91abdb08d6 100644
--- a/Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs
+++ b/Darling/Darling.Tests/ViewerTimeRangeWindowTests.cs
@@ -74,25 +74,71 @@ public void ASubHourSpan_FlowsThroughTheWindow_AndRoundsUpToWholeHoursOnlyForThe
     [Fact]
     public void ARangeThatCannotResolveYet_FallsBackToTwentyFourHours()
     {
-        // Midnight plus one minute: Today is under the 5-minute floor.
+        // A since-range whose start has not happened yet cannot resolve: the Viewer's historical 24 hours stands in.
+        var nowUtc = new DateTime(2026, 10, 8, 4, 1, 0, DateTimeKind.Unspecified);
+        var (start, end, live) = ViewerTimeRangeWindow.Window(TimeRangeSpec.SinceInstant(nowUtc.AddHours(1)), nowUtc, Eastern);
+
+        Assert.Equal(TimeSpan.FromHours(24), end - start);
+        Assert.True(live);
+    }
+
+    [Fact]
+    public void TodayInItsFirstMinutes_ReadsMidnightToNow_NeverAnotherRange()
+    {
+        // 00:01 in New York: exempt from the 5-minute floor (seat ruling), so it reads 00:00 to now.
         var justAfterMidnight = new DateTime(2026, 10, 8, 4, 1, 0, DateTimeKind.Unspecified);
         var (start, end, live) = ViewerTimeRangeWindow.Window(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), justAfterMidnight, Eastern);
 
-        Assert.Equal(TimeSpan.FromHours(24), end - start);
+        Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), start);
+        Assert.Equal(justAfterMidnight, end);
         Assert.True(live);
     }
 
+    [Theory]
+    [InlineData("Queries", "Query Store by Duration", "query_store")]
+    [InlineData("Queries", "Active Queries", "query_snapshots")]
+    [InlineData("Queries", null, "query_stats")]
+    [InlineData("Blocking", "Current Waits", "waiting_tasks")]
+    [InlineData("Blocking", "Blocked Process Reports", "blocked_process_report")]
+    [InlineData("Memory", "Memory Clerks", "memory_clerks")]
+    [InlineData("CPU", "CPU Scheduler", "cpu_scheduler_stats")]
+    [InlineData("Wait Stats", "anything", "wait_stats")]
+    public void TheMainCollector_FollowsTheSubTabOnScreen_AsLiteDoes(string tab, string? sub, string expected)
+    {
+        Assert.Equal(expected, ViewerTimeRangeWindow.MainCollectorFor(tab, sub));
+        Assert.True(PerformanceMonitor.Collectors.CollectorScheduleDefaults.All.ContainsKey(expected));
+    }
+
+    [Theory]
+    [InlineData("400000mo")]
+    [InlineData("1000000d")]
+    [InlineData("999999w")]
+    public void ACorruptPreferenceRange_FallsBackToTheIndexWithoutThrowing(string corrupt)
+    {
+        /* #5562 review H1: a hand-edited viewer-preferences.json used to throw OverflowException from Load() at startup. */
+        var prefs = new ViewerPreferences { DefaultTimeRange = corrupt, DefaultTimeRangeIndex = 1 }.Normalize();
+        Assert.Equal("4h", prefs.DefaultTimeRange);
+        Assert.Equal(1, prefs.DefaultTimeRangeIndex);
+    }
+
+    [Fact]
+    public void JobHistory_LongestChoice_IsAYear()
+    {
+        Assert.Equal(TimeSpan.FromDays(365), ViewerTimeRangeWindow.JobHistoryLongestChoice.Span);
+        Assert.False(TimeRangeSpec.TryFromId("1y", out _));
+    }
+
     [Fact]
     public void ApplyToAll_SendsACalendarPeriodAsTheInstantsItNames_AndLeavesARollingRangeAlone()
     {
         var rolling = TimeRangeSpec.Relative(TimeSpan.FromHours(4));
-        Assert.Same(rolling, ViewerTimeRangeWindow.ForBroadcast(rolling, Now, Eastern));
+        Assert.Same(rolling, TimeRangePresets.ForBroadcast(rolling, Now, Eastern));
 
-        var today = ViewerTimeRangeWindow.ForBroadcast(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), Now, Eastern);
+        var today = TimeRangePresets.ForBroadcast(TimeRangeSpec.ForPeriod(CalendarPeriod.Today), Now, Eastern);
         Assert.Equal(TimeRangeKind.Since, today.Kind);
         Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), today.StartUtc);
 
-        var yesterday = ViewerTimeRangeWindow.ForBroadcast(TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday), Now, Eastern);
+        var yesterday = TimeRangePresets.ForBroadcast(TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday), Now, Eastern);
         Assert.Equal(TimeRangeKind.Fixed, yesterday.Kind);
         Assert.Equal(new DateTime(2026, 10, 7, 4, 0, 0), yesterday.StartUtc);
         Assert.Equal(new DateTime(2026, 10, 8, 4, 0, 0), yesterday.EndUtc);
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml
index d14225223d..8861acae37 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml
+++ b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml
@@ -70,7 +70,7 @@
                        Foreground="{DynamicResource ForegroundBrush}"/>
             <TextBlock Text="Time Range:" VerticalAlignment="Center" Margin="5,0,4,0"
                        Foreground="{DynamicResource ForegroundMutedBrush}"/>
-            <!-- #5562: the shared time range picker. 30 days is the "1mo" preset; 90 days and a year are typed ("90d", "365d"). -->
+            <!-- #5562: the shared time range picker. 30 days is the "1mo" preset, a year is the longest choice ("Last Year", 365 days), 90 days is typed ("90d"). -->
             <ui:TimeRangePicker x:Name="TimeRangePickerControl" Compact="True" VerticalAlignment="Center"
                                 RangeChanged="TimeRangePicker_RangeChanged"/>
             <TextBlock Text="Server:" VerticalAlignment="Center" Margin="12,0,4,0"
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
index a2cf39ae36..085749808c 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/JobHistoryTab.xaml.cs
@@ -52,6 +52,8 @@ public JobHistoryTab()
            one click away in the picker's presets (1w, 1mo) and a typed "90d". */
         TimeRangePickerControl.ZoneProvider = ViewerTimeHelper.CurrentDisplayZone;
         TimeRangePickerControl.Value = TimeRangePresets.Find("1d")!;
+        /* R8: the old "Last Year" (365 days). The parser has no year unit, so "1y" cannot be typed; this choice is the way to a year. */
+        TimeRangePickerControl.SetLongestChoice(ViewerTimeRangeWindow.JobHistoryLongestChoice, "Last Year");
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
index c92ad07a88..5f78a219c9 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.TimeRange.cs
@@ -40,7 +40,7 @@ public partial class ViewerServerTab
 
     /// <summary>
     /// Raised when the user clicks "Apply to All": MainWindow broadcasts the held range to every other open server
-    /// tab (<see cref="ViewerTimeRangeWindow.ForBroadcast"/>: a calendar period goes as the instants it names). The
+    /// tab (<see cref="TimeRangePresets.ForBroadcast"/>: a calendar period goes as the instants it names). The
     /// source tab is carried so the broadcast can skip it (it already holds the range).
     /// </summary>
     public event Action<ViewerServerTab, TimeRangeSpec>? ApplyTimeRangeRequested;
@@ -165,6 +165,42 @@ private int GetWindowHoursBack()
     /// and on every refresh, so a range that slides with now shows the window it is reading.</summary>
     private void RefreshRangePicker() => RangePicker.Refresh();
 
+    /// <summary>The main collector of the page on screen: the inner tab's header and, when that tab holds a sub-tab control, the
+    /// selected sub-tab's (<see cref="ViewerTimeRangeWindow.MainCollectorFor(string?, string?)"/>). Never widens the range.</summary>
+    private string? CurrentMainCollector()
+    {
+        if (InnerTabs?.SelectedItem is not TabItem top)
+        {
+            return null;
+        }
+
+        string? sub = null;
+        if (top.Content is DependencyObject content && FindFirstTabControl(content) is { SelectedItem: TabItem selected })
+        {
+            sub = selected.Header as string;
+        }
+
+        return ViewerTimeRangeWindow.MainCollectorFor(top.Header as string, sub);
+    }
+
+    private static TabControl? FindFirstTabControl(DependencyObject parent)
+    {
+        foreach (var child in LogicalTreeHelper.GetChildren(parent))
+        {
+            if (child is TabControl tabs)
+            {
+                return tabs;
+            }
+
+            if (child is DependencyObject next && FindFirstTabControl(next) is { } found)
+            {
+                return found;
+            }
+        }
+
+        return null;
+    }
+
     /// <summary>
     /// Sets the picker's "collected every N minutes" note (#5562 R3) from the main collector of the inner tab on screen and
     /// that collector's ACTUAL interval on this server (the schedule overrides, else the shipped default). A read that
@@ -174,7 +210,7 @@ private async Task UpdateSampleIntervalAsync()
     {
         try
         {
-            var collector = ViewerTimeRangeWindow.MainCollectorFor((InnerTabs?.SelectedItem as TabItem)?.Header as string);
+            var collector = CurrentMainCollector();
             if (!string.Equals(collector, _noteCollector, StringComparison.Ordinal))
             {
                 /* A different top-level tab: the data-start note belonged to the last tab's surface, so it clears here and
@@ -288,7 +324,7 @@ private void ApplyTimeRangeToAll_Click(object sender, RoutedEventArgs e)
     {
         /* A calendar period goes as the instants it names in THIS tab's zone, a fixed range as its held instants: every
            other tab draws them in its own server's zone, so all of them window on the same period (#4766, #5562). */
-        ApplyTimeRangeRequested?.Invoke(this, ViewerTimeRangeWindow.ForBroadcast(RangePicker.Value, DateTime.UtcNow, TabDisplayZone));
+        ApplyTimeRangeRequested?.Invoke(this, TimeRangePresets.ForBroadcast(RangePicker.Value, DateTime.UtcNow, TabDisplayZone));
     }
 
     // ── Time-display mode (Server / Local / UTC) ─────────────────────────────────────
@@ -419,7 +455,7 @@ public void SetDisplayModeSelection(TimeDisplayMode mode)
 
     /// <summary>
     /// Applies a range chosen on another server tab (the "Apply to All" broadcast). The range arrives as a spec whose
-    /// instants are already fixed where they must be (<see cref="ViewerTimeRangeWindow.ForBroadcast"/>): this tab holds
+    /// instants are already fixed where they must be (<see cref="TimeRangePresets.ForBroadcast"/>): this tab holds
     /// it and draws it in ITS zone, so every tab windows on the same period whatever its server's clock (#4766). Sets
     /// the picker under the suppress guard so the copy doesn't cascade multiple reloads, then, when this is the
     /// visible tab, drives exactly one reload of its active inner tab. A hidden tab holds the range and reloads when it
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs
index da07d353d9..96545815e5 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerServerTab.xaml.cs
@@ -292,9 +292,8 @@ visible tab renders (the viewer's visible-only rule), so its offset wins. Loaded
             await UpdatePermissionDeniedBadgeAsync();
 
             /* #5562: redraw the picker's resolved range from the clock (a range that slides with now) and refresh its
-               "collected every N minutes" note for the inner tab on screen. Chrome: its own try/catch keeps it off the load path. */
+               "collected every N minutes" note (set for the page on screen in the load loop below, before each tab's load). */
             RefreshRangePicker();
-            await UpdateSampleIntervalAsync();
 
             do
             {
@@ -304,6 +303,9 @@ visible tab renders (the viewer's visible-only rule), so its offset wins. Loaded
                 do
                 {
                     loadedTab = InnerTabs.SelectedIndex;
+                    /* L3: a tab switched to during this load changes the page on screen, so its note is set here too, not only
+                       at the top of the pass. */
+                    await UpdateSampleIntervalAsync();
                     await LoadInnerTabAsync(loadedTab);
                 }
                 while (InnerTabs.SelectedIndex != loadedTab);
diff --git a/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs b/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
index 17705b1636..3149a5cc07 100644
--- a/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
+++ b/Darling/PerformanceMonitor.Darling.Viewer/ViewerTimeRangeWindow.cs
@@ -17,14 +17,14 @@ namespace PerformanceMonitor.Darling.Viewer;
 /// <summary>
 /// The pure half of the Viewer's time range (#5562): how a <see cref="TimeRangeSpec"/> the shared picker holds becomes
 /// the naive-UTC window every inner tab reads, the whole hours the few integer readers still take, the legacy
-/// preset index old preference files hold, what "Apply to All" sends, and which collector a tab's chart is fed by (for
+/// preset index old preference files hold, and which collector a tab's chart is fed by (for
 /// the picker's "collected every N minutes" note). Nothing here reads the clock, the zone or a control, so a test pins
 /// each rule without a window (a <c>ViewerServerTab</c> needs the app's resources and cannot be built in a test).
 /// </summary>
 internal static class ViewerTimeRangeWindow
 {
-    /// <summary>The window a range that cannot be resolved right now (Today in its first minutes, which is under the
-    /// 5-minute floor) falls back to: the Viewer's historical 24 hours, so no surface is ever window-less.</summary>
+    /// <summary>The window a range that cannot be resolved right now (a 'since' start that has not happened yet; a calendar
+    /// period is exempt from the 5-minute floor) falls back to: the Viewer's historical 24 hours, so no surface is ever window-less.</summary>
     internal static readonly TimeSpan FallbackSpan = TimeSpan.FromHours(24);
 
     /// <summary>The window to read now: the range's start and end as naive UTC, and whether the end slides with the
@@ -81,22 +81,6 @@ internal static int ToLegacyIndex(TimeRangeSpec spec)
             _ => ViewerPreferences.DefaultTimeRangeIndexValue,
         };
 
-    /// <summary>What "Apply to All" sends for a held range. A relative range and a fixed or since range go as they are
-    /// (every tab then windows on the same period, as #4766 settled). A calendar period is resolved ONCE here, in the
-    /// source tab's zone, and sent as the instants it names - or as a since range while it still runs (Today) - because
-    /// each tab draws its own server's clock and "Today" would otherwise mean a different day on each. A period that
-    /// cannot be resolved right now goes as it is.</summary>
-    internal static TimeRangeSpec ForBroadcast(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
-    {
-        ArgumentNullException.ThrowIfNull(spec);
-        if (spec.Kind != TimeRangeKind.Calendar || !spec.TryResolve(nowUtc, zone, out var range, out _) || range is null)
-        {
-            return spec;
-        }
-
-        return range.IsLive ? TimeRangeSpec.SinceInstant(range.StartUtc) : TimeRangeSpec.FixedRange(range.StartUtc, range.EndUtc);
-    }
-
     /// <summary>The collector that feeds the first chart of a top-level inner tab, by the tab's header, or null for a tab
     /// that has no single main collector (it then shows no sample-interval note). Names are
     /// <see cref="CollectorScheduleDefaults"/> keys.</summary>
@@ -113,6 +97,47 @@ internal static TimeRangeSpec ForBroadcast(TimeRangeSpec spec, DateTime nowUtc,
         _ => null,
     };
 
+    /// <summary>The collector behind the page on screen (#5562 L3): the top-level tab's header and, for a tab that holds sub-tabs, the
+    /// selected sub-tab's, as Lite's <c>LiteTimeRange.MainCollectorFor</c> does, so Queries &gt; Query Store names the 5-minute
+    /// collector and Blocking &gt; Current Waits the waiting-tasks one. A sub-tab with no entry here, or none, falls back to the
+    /// top-level tab's collector (<see cref="MainCollectorFor(string?)"/>).</summary>
+    internal static string? MainCollectorFor(string? innerTabHeader, string? subTabHeader)
+    {
+        var bySubTab = innerTabHeader switch
+        {
+            "Queries" => subTabHeader switch
+            {
+                "Performance Trends" => "query_stats",
+                "Active Queries" => "query_snapshots",
+                "Top Queries by Duration" => "query_stats",
+                "Top Procedures by Duration" => "procedure_stats",
+                "Query Store by Duration" => "query_store",
+                "Plan Corrections" => "plan_correction",
+                "Query Heatmap" => "query_stats",
+                _ => null,
+            },
+            "CPU" => subTabHeader == "CPU Scheduler" ? "cpu_scheduler_stats" : null,
+            "Memory" => subTabHeader switch
+            {
+                "Memory Clerks" => "memory_clerks",
+                "Memory Grants" => "memory_grant_stats",
+                "Plan Cache" => "plan_cache_stats",
+                "Memory Pressure Events" => "memory_pressure_events",
+                _ => null,
+            },
+            "Blocking" => subTabHeader switch
+            {
+                "Current Waits" => "waiting_tasks",
+                "Deadlocks" => "deadlocks",
+                "Blocking Stats" => "deadlocks",
+                _ => null,
+            },
+            _ => null,
+        };
+
+        return bySubTab ?? MainCollectorFor(innerTabHeader);
+    }
+
     /// <summary>How often <paramref name="collector"/> actually runs on this server: its fleet or per-server schedule
     /// override if there is one, else the shipped default (<see cref="CollectorScheduleDefaults"/>). Null for a collector
     /// that is not scheduled on a cadence (on load) or is not known, so the picker shows no note rather than a wrong one.</summary>
@@ -133,6 +158,10 @@ internal static TimeRangeSpec ForBroadcast(TimeRangeSpec spec, DateTime nowUtc,
     internal static TimeRangeSpec AlertHistoryLongestChoice { get; } =
         TimeRangeSpec.Relative(TimeSpan.FromDays(Math.Min(DarlingRetentionHorizons.AlertHistoryRetentionDays, 365)));
 
+    /// <summary>The longest choice Job History offers (#5562 R8): 365 days, the old "Last Year", the same on Lite. The parser has no
+    /// year unit, so this choice is the way to a year.</summary>
+    internal static TimeRangeSpec JobHistoryLongestChoice { get; } = TimeRangeSpec.Relative(TimeSpan.FromDays(365));
+
     /// <summary>The range a newly-opened tab starts on, from the persisted preference (a string id wins; the legacy
     /// index stands in for a file written before the string existed).</summary>
     internal static TimeRangeSpec DefaultFor(ViewerPreferences preferences)
diff --git a/Lite.Tests/LiteTimeRangeGapTests.cs b/Lite.Tests/LiteTimeRangeGapTests.cs
index dcfc249988..c6ad3e9572 100644
--- a/Lite.Tests/LiteTimeRangeGapTests.cs
+++ b/Lite.Tests/LiteTimeRangeGapTests.cs
@@ -7,14 +7,17 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using DuckDB.NET.Data;
+using PerformanceMonitor.Analysis.Baselines;
 using PerformanceMonitor.Collectors;
 using PerformanceMonitor.Ui;
+using PerformanceMonitorLite.Controls;
 using PerformanceMonitorLite.Database;
 using PerformanceMonitorLite.Helpers;
 using PerformanceMonitorLite.Models;
@@ -25,9 +28,10 @@ namespace PerformanceMonitorLite.Tests;
 
 /// <summary>
 /// #5562 gaps the first Lite pass left: FinOps pickers are rolling only (R5), Job History and Alert History read a real END
-/// bound ahead of their row caps (R6), Alert History's longest choice is the alert log's retention (R8), the sample note
+/// bound ahead of their row caps (R6), the longest choices are 365 days (R8), the sample note
 /// names the main collector of the sub-tab on screen (R3), and every banner site feeds the picker's data start (R7).
 /// </summary>
+[Collection("server-time-helper")]
 public sealed class LiteTimeRangeGapTests : IClassFixture<SharedDuckDbFixture>, IDisposable
 {
     private readonly DuckDbInitializer _duckDb;
@@ -152,18 +156,6 @@ DateTime Wall(DateTime utc)
         Assert.All(unbounded, r => Assert.StartsWith("after_", r.JobId)); /* the old shape spent the whole cap after the end */
     }
 
-    [Fact]
-    public void JobHistoryTab_PassesTheRangeEndToTheRead_AndTheEndIsExclusive()
-    {
-        var tab = LiteFile(Path.Combine("Controls", "JobHistoryTab.xaml.cs"));
-        var sql = LiteFile(Path.Combine("Services", "LocalDataService.JobHistory.cs"));
-
-        Assert.Contains("GetJobHistoryWithClocksAsync(startUtc, RowCap, serverId, openTabClocks, rangeEndUtc)", tab, StringComparison.Ordinal);
-        Assert.Contains("LiteTimeRange.BoundsOf(RangePicker, 24, nowUtc)", tab, StringComparison.Ordinal);
-        Assert.Equal(2, Regex.Matches(sql, @"\{endClause\}").Count); /* job_stats and base, both ahead of the LIMIT */
-        Assert.Contains("run_datetime < $5", sql, StringComparison.Ordinal);
-    }
-
     // ---- Alert History: start and exclusive end, Dismiss All scope ----
 
     private async Task InsertAlertAsync(DateTime alertTimeUtc, string metric)
@@ -210,18 +202,67 @@ public async Task AlertHistory_FinishedRangeShowsNoAlertAfterItsEnd_AndDismissAl
 
     // ---- R8: Alert History's longest choice ----
 
-    [Theory]
-    [InlineData(2026, 10, 8, 92)] /* Jul 8 to Oct 8 */
-    [InlineData(2026, 3, 1, 90)]  /* Dec 1 to Mar 1 */
-    [InlineData(2026, 6, 1, 92)]  /* Mar 1 to Jun 1 */
-    public void AlertHistoryLongest_IsTheAlertLogsRetentionInDays(int year, int month, int day, int days)
+    [Fact]
+    public void AlertHistoryLongest_IsAYear_BecauseLiteKeepsRowsPastThreeMonths()
     {
-        var now = new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
-        Assert.Equal(TimeSpan.FromDays(days), LiteTimeRange.AlertHistoryLongest(now));
-        Assert.Equal(TimeRangeSpec.Relative(TimeSpan.FromDays(days)), LiteTimeRange.AlertHistoryLongestChoice(now));
+        /* Archive files are deleted by whole month, 3 months back (RetentionService.OldestRetainedInstant), so a row older than
+           3 months survives until its month's file goes: a 3-month "All" would hide it. */
         Assert.Equal(3, RetentionService.ArchiveRetentionMonths);
-        Assert.True(LiteTimeRange.AlertHistoryLongest(now) <= TimeSpan.FromDays(365));
+        Assert.Equal(TimeSpan.FromDays(365), LiteTimeRange.AlertHistoryLongest);
+        Assert.Equal(TimeRangeSpec.Relative(TimeSpan.FromDays(365)), LiteTimeRange.AlertHistoryLongestChoice);
+        Assert.Equal(TimeRangeSpec.Relative(TimeSpan.FromDays(365)), LiteTimeRange.JobHistoryLongestChoice);
 
+        /* The parser has no year unit, so no text may claim "1y" can be typed. */
+        Assert.False(TimeRangeSpec.TryFromId("1y", out _));
+    }
+
+    [Fact]
+    public void JobHistoryZone_IsTheZoneTheGridWordsItsRowsIn_SoYesterdayMeansTheGridsYesterday()
+    {
+        /* #5562 M1: all servers are worded in UTC, one server in its own clock (its last read's, else its open tab's, else the machine's). */
+        var eastern = ServerClock.Resolve("Eastern Standard Time", -300);
+        var now = new DateTime(2026, 10, 8, 2, 0, 0, DateTimeKind.Unspecified);
+        var yesterday = TimeRangeSpec.ForPeriod(CalendarPeriod.Yesterday);
+
+        var allServers = JobHistoryTab.JobHistoryZone(null, new Dictionary<int, ServerClock> { [7] = eastern }, null);
+        Assert.Equal(TimeZoneInfo.Utc, allServers);
+        Assert.True(yesterday.TryResolve(now, allServers, out var inUtc, out _));
+        Assert.Equal(new DateTime(2026, 10, 7, 0, 0, 0), inUtc!.StartUtc);
+        Assert.Equal(new DateTime(2026, 10, 8, 0, 0, 0), inUtc.EndUtc);
+
+        var oneServer = JobHistoryTab.JobHistoryZone(7, new Dictionary<int, ServerClock> { [7] = eastern }, null);
+        Assert.True(yesterday.TryResolve(now, oneServer, out var inEastern, out _));
+        Assert.Equal(new DateTime(2026, 10, 6, 4, 0, 0), inEastern!.StartUtc);
+        Assert.Equal(new DateTime(2026, 10, 7, 4, 0, 0), inEastern.EndUtc);
+
+        /* No read yet for this server: its open tab's clock, then the machine's. */
+        var viaTab = JobHistoryTab.JobHistoryZone(7, new Dictionary<int, ServerClock>(), new Dictionary<int, ServerClock> { [7] = eastern });
+        Assert.True(yesterday.TryResolve(now, viaTab, out var viaTabRange, out _));
+        Assert.Equal(inEastern.StartUtc, viaTabRange!.StartUtc);
+        Assert.Equal(TimeZoneInfo.Local, JobHistoryTab.JobHistoryZone(7, null, null));
+    }
+
+    [Fact]
+    public void TheAlertAndFinOpsPickers_ReadInTheDisplayModesZone()
+    {
+        var eastern = ServerClock.Resolve("Eastern Standard Time", -300);
+        var mode = ServerTimeHelper.CurrentDisplayMode;
+        var clock = ServerTimeHelper.ActiveServerClock;
+        try
+        {
+            ServerTimeHelper.ActiveServerClock = eastern;
+            ServerTimeHelper.CurrentDisplayMode = TimeDisplayMode.UTC;
+            Assert.Equal(TimeZoneInfo.Utc, ServerTimeHelper.CurrentDisplayZone);
+            ServerTimeHelper.CurrentDisplayMode = TimeDisplayMode.LocalTime;
+            Assert.Equal(TimeZoneInfo.Local, ServerTimeHelper.CurrentDisplayZone);
+            ServerTimeHelper.CurrentDisplayMode = TimeDisplayMode.ServerTime;
+            Assert.Equal(eastern.AsTimeZone().BaseUtcOffset, ServerTimeHelper.CurrentDisplayZone.BaseUtcOffset);
+        }
+        finally
+        {
+            ServerTimeHelper.ActiveServerClock = clock;
+            ServerTimeHelper.CurrentDisplayMode = mode;
+        }
     }
 
     // ---- R3: the sample note names the sub-tab's main collector ----
@@ -323,7 +364,7 @@ public void EveryBannerSite_FeedsThePickersDataStart()
         /* The central funnel feeds for every relation, and the tab points the picker at the page on screen. */
         var refresh = LiteFile(Path.Combine("Controls", "ServerTab.Refresh.cs"));
         Assert.DoesNotContain("if (relation == QueryWindowRelation.QueryStats)\n        {\n            RangePicker.DataStartUtc", refresh, StringComparison.Ordinal);
-        Assert.Contains("RangePicker.SetLongestChoice(LiteTimeRange.AlertHistoryLongestChoice(", LiteFile(Path.Combine("Controls", "AlertsHistoryTab.xaml.cs")), StringComparison.Ordinal);
+        Assert.Contains("RangePicker.SetLongestChoice(LiteTimeRange.AlertHistoryLongestChoice, ", LiteFile(Path.Combine("Controls", "AlertsHistoryTab.xaml.cs")), StringComparison.Ordinal);
         Assert.Contains("CorrelatedLanes.DataStartFound +=", LiteFile(Path.Combine("Controls", "ServerTab.xaml.cs")), StringComparison.Ordinal);
     }
 
diff --git a/Lite.Tests/ServerTabHeldRangeTests.cs b/Lite.Tests/ServerTabHeldRangeTests.cs
index a10e3bdb32..846a58c356 100644
--- a/Lite.Tests/ServerTabHeldRangeTests.cs
+++ b/Lite.Tests/ServerTabHeldRangeTests.cs
@@ -136,16 +136,6 @@ public void ThePickerZone_IsUtc_ThisMachinesZone_OrTheTabsOwnServerClock()
         Assert.Equal(TimeSpan.FromHours(-5), server.GetUtcOffset(DateTime.SpecifyKind(At(11, 1, 6, 30), DateTimeKind.Utc)));
     }
 
-    [Fact]
-    public void ADrillWindowUnderTheFiveMinuteFloor_IsCentredAndHeldAtFiveMinutes()
-    {
-        var (from, to) = LiteTimeRange.AtLeastMinimumSpan(At(10, 8, 12, 0), At(10, 8, 12, 2));
-        Assert.Equal((At(10, 8, 11, 58).AddSeconds(30), At(10, 8, 12, 3).AddSeconds(30)), (from, to));
-
-        var longer = (At(10, 8, 12, 0), At(10, 8, 12, 30));
-        Assert.Equal(longer, LiteTimeRange.AtLeastMinimumSpan(longer.Item1, longer.Item2));
-    }
-
     // ── Settings: the legacy hours key keeps working, default_time_range is optional ──
 
     [Theory]
@@ -164,11 +154,24 @@ public void TheLegacyHoursKey_MapsThroughFromLegacyHours(int hours, string expec
     [Theory]
     [InlineData(0)]
     [InlineData(-3)]
+    [InlineData(int.MaxValue)]
+    [InlineData(300_000_000)]
     public void ANonsenseLegacyValue_OpensOnFourHours(int hours)
     {
         Assert.Equal("4h", LiteTimeRange.FromSettings(null, hours).Id);
     }
 
+    [Theory]
+    [InlineData("400000mo")]
+    [InlineData("1000000d")]
+    [InlineData("999999w")]
+    public void ACorruptRangeId_FallsBackWithoutThrowing(string id)
+    {
+        /* #5562 review H1: a hand-edited settings.json used to throw OverflowException when a server tab was built. */
+        Assert.Equal("4h", LiteTimeRange.FromSettings(id, 0).Id);
+        Assert.Equal("1d", LiteTimeRange.FromSettings(id, 24).Id);
+    }
+
     [Fact]
     public void TheNewKey_WinsForAPresetOrAPeriod_AndANonPersistableOneFallsBackToTheHours()
     {
diff --git a/Lite/Controls/AlertsHistoryTab.xaml.cs b/Lite/Controls/AlertsHistoryTab.xaml.cs
index 22a350859b..5ec36eed59 100644
--- a/Lite/Controls/AlertsHistoryTab.xaml.cs
+++ b/Lite/Controls/AlertsHistoryTab.xaml.cs
@@ -63,9 +63,12 @@ public AlertsHistoryTab()
     {
         InitializeComponent();
         RangePicker.Value = TimeRangePresets.FromLegacyHours(24)!; /* 24 hours, as the list opened */
-        /* R8: "All" is a span as long as the alert log is kept (3 months on Lite, RetentionService.ArchiveRetentionMonths), through
-           the shared control's longest choice, as the Darling Viewer's Alert History does. */
-        RangePicker.SetLongestChoice(LiteTimeRange.AlertHistoryLongestChoice(DateTime.UtcNow), "All");
+        /* #5562 M1: typed times and calendar periods are read in the zone the Time column is worded in (the display mode), as the
+           Darling Viewer's Alert History does with its display zone. */
+        RangePicker.ZoneProvider = () => ServerTimeHelper.CurrentDisplayZone;
+        /* R8: "All" is a span of 365 days, longer than anything Lite keeps (archive files are deleted by whole month, 3 months
+           back, so rows older than 3 months survive until their month's file goes), through the shared control's longest choice. */
+        RangePicker.SetLongestChoice(LiteTimeRange.AlertHistoryLongestChoice, "All");
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
diff --git a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
index bd3b7a963f..289c427d0a 100644
--- a/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
+++ b/Lite/Controls/CorrelatedTimelineLanesControl.xaml.cs
@@ -368,15 +368,15 @@ await ShowBlockingLaneDataStartAsync(
         }
     }
 
+    /// <summary>Raised with the data start the blocking lane's note chose (#5562 R7), so the tab's picker can name it. Null when the note found none.</summary>
+    internal event Action<DateTime?>? DataStartFound;
+
     /// <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>
-    /// <summary>Raised with the data start the blocking lane's note chose (#5562 R7), so the tab's picker can name it. Null when the note found none.</summary>
-    internal event Action<DateTime?>? DataStartFound;
-
     private async Task ShowBlockingLaneDataStartAsync(
         DateTime startUtc, DateTime endUtc, IReadOnlyList<TrendPoint> blockingBars, IReadOnlyList<TrendPoint> deadlockBars)
     {
diff --git a/Lite/Controls/JobHistoryTab.xaml.cs b/Lite/Controls/JobHistoryTab.xaml.cs
index 1db7f1fb8e..45a0c8afc4 100644
--- a/Lite/Controls/JobHistoryTab.xaml.cs
+++ b/Lite/Controls/JobHistoryTab.xaml.cs
@@ -43,7 +43,11 @@ public partial class JobHistoryTab : UserControl
     public JobHistoryTab()
     {
         InitializeComponent();
-        RangePicker.Value = TimeRangePresets.FromLegacyHours(24)!; /* 24 hours, as the list opened; '1mo' is the old 30 days, '90d' or '1y' can be typed */
+        RangePicker.Value = TimeRangePresets.FromLegacyHours(24)!; /* 24 hours, as the list opened; '1mo' is the old 30 days, '90d' can be typed */
+        /* R8: the old "Last Year" (365 days). The parser has no year unit, so "1y" cannot be typed; this choice is the way to a year. */
+        RangePicker.SetLongestChoice(LiteTimeRange.JobHistoryLongestChoice, "Last Year");
+        /* #5562 M1: typed times and calendar periods are read in the zone the grid words its rows in (see PickerZone). */
+        RangePicker.ZoneProvider = PickerZone;
         _staleDataTimer = new DispatcherTimer { Interval = TimeSpan.FromSeconds(10) };
         _staleDataTimer.Tick += StaleDataTimer_Tick;
     }
@@ -80,6 +84,42 @@ public async void RefreshJobs()
     /// "Showing since" note names the oldest run of a page this full (#4966).</summary>
     internal const int RowCap = 2000;
 
+    /// <summary>The clocks the last read worked each server's window on (<see cref="LocalDataService.GetJobHistoryWithClocksAsync"/>), kept so the picker can word a single server's range in the same clock.</summary>
+    private readonly Dictionary<int, ServerClock> _readClocks = new();
+
+    /// <summary>
+    /// The zone the picker reads typed times and calendar periods in (#5562 M1): the zone the grid words its rows in. For one
+    /// server that is its wall clock (the clock its last read used, else its open tab's, else this machine's, the chain
+    /// <see cref="ServerTimeHelper.ClockForServer(ServerClock?, ServerClock?)"/> follows); for All Servers it is UTC, since the rows
+    /// sit on different servers' clocks (<see cref="ShowDataStartNoteAsync"/>).
+    /// </summary>
+    internal static TimeZoneInfo JobHistoryZone(int? serverId, IReadOnlyDictionary<int, ServerClock>? readClocks, IReadOnlyDictionary<int, ServerClock>? openTabClocks)
+    {
+        if (serverId is not int one)
+        {
+            return TimeZoneInfo.Utc;
+        }
+
+        if (readClocks is not null && readClocks.TryGetValue(one, out var read))
+        {
+            return read.AsTimeZone();
+        }
+
+        if (openTabClocks is not null && openTabClocks.TryGetValue(one, out var tab))
+        {
+            return tab.AsTimeZone();
+        }
+
+        return TimeZoneInfo.Local;
+    }
+
+    private TimeZoneInfo PickerZone()
+    {
+        /* The open tabs' clocks are only asked for when the last read has none for this server (they are UI objects). */
+        var serverId = GetSelectedServerId();
+        return JobHistoryZone(serverId, _readClocks, serverId is int id && !_readClocks.ContainsKey(id) ? _openTabClocks?.Invoke() : null);
+    }
+
     private async System.Threading.Tasks.Task LoadJobsAsync()
     {
         if (_dataService == null) return;
@@ -105,6 +145,11 @@ starting of two overlapping reads can land first. Same idiom as FinOpsTab's. */
             var (all, readClocks) = await System.Threading.Tasks.Task.Run(() => _dataService.GetJobHistoryWithClocksAsync(startUtc, RowCap, serverId, openTabClocks, rangeEndUtc));
             if (_loads.Superseded(nameof(LoadJobsAsync), gen)) return;
 
+            foreach (var (id, readClock) in readClocks)
+            {
+                _readClocks[id] = readClock;
+            }
+
             /* #2126: rows carry the raw collected server name; swap in the operator's alias where the
                config layer knows one, so the Server column and filter speak the same names as every
                other tab. A server no longer in config keeps its raw name (the durable-record case). */
diff --git a/Lite/Controls/ServerTab.DrillDown.cs b/Lite/Controls/ServerTab.DrillDown.cs
index d4f6f95023..e2cfc42a6c 100644
--- a/Lite/Controls/ServerTab.DrillDown.cs
+++ b/Lite/Controls/ServerTab.DrillDown.cs
@@ -210,9 +210,8 @@ private async void OnHeatmapDrillDown(DateTime bucketTimeUtc)
     private void SetDrillDownTimeRange(DateTime fromUtc, DateTime toUtc)
     {
         /* The drill's window is held as the instants it names (#4766, #5562): a fixed range, which the picker shows in the
-           display zone. The model refuses anything under 5 minutes, so a narrower drill is centred and held at 5 minutes
-           (the drilled grid itself still reads the exact pair it was handed). */
-        (fromUtc, toUtc) = LiteTimeRange.AtLeastMinimumSpan(fromUtc, toUtc);
+           display zone. It is held exactly as handed and never widened (R3): every drill caller passes 15 minutes or more. */
+        _probedFloors.Clear();
 
         // Hold it without triggering a refresh (Value raises no RangeChanged; the flag covers a handler that might)
         _suppressRangeRefresh = true;
diff --git a/Lite/Controls/ServerTab.TimeRange.cs b/Lite/Controls/ServerTab.TimeRange.cs
index 696b07af45..8e0dae6f64 100644
--- a/Lite/Controls/ServerTab.TimeRange.cs
+++ b/Lite/Controls/ServerTab.TimeRange.cs
@@ -38,9 +38,10 @@ public partial class ServerTab : UserControl
 {
     /// <summary>
     /// The range the toolbar picker holds, resolved against the clock now (#5562). A live range (the last 5 minutes,
-    /// 'Today', 'since ...') slides with every call. When the held range cannot be used at this moment ('Today' in the
-    /// first minutes after midnight is under the 5-minute floor) the last window that did resolve keeps being read, so
-    /// a refresh never reads nothing; with none yet, the default of four hours.
+    /// 'Today', 'since ...') slides with every call. A calendar period is exempt from the 5-minute floor ('Today' at
+    /// 00:02 reads 00:00 to now; the sample note explains a sparse chart). When the held range cannot be used at this moment
+    /// (a 'since' start that has not happened yet) the last window that did resolve keeps being read, so a refresh never
+    /// reads nothing; with none yet, the default of four hours.
     /// </summary>
     private ResolvedTimeRange CurrentRange()
     {
@@ -214,11 +215,18 @@ internal static (DateTime Start, DateTime End) GetChartWindow(
     /// Holds <paramref name="spec"/> on this tab as if the user picked it (used by Apply to All): the picker redraws, and its
     /// RangeChanged handler persists the choice and refreshes. A range this tab cannot use right now is left as it was.
     /// </summary>
-    public void SetTimeRange(TimeRangeSpec spec) => RangePicker.Select(spec);
+    public void SetTimeRange(TimeRangeSpec spec)
+    {
+        _probedFloors.Clear();
+        RangePicker.Select(spec);
+    }
 
     private void ApplyTimeRangeToAll_Click(object sender, RoutedEventArgs e)
     {
-        ApplyTimeRangeRequested?.Invoke(RangePicker.Value);
+        /* #5562 M2: a calendar period goes as the instants it names in THIS tab's zone, a fixed range as its held instants. Every
+           other tab resolves in its own server's clock in Server mode, so "Today" sent unresolved would be a different day on each
+           (#4766 settled that they window on the same period; the Viewer does the same through the same helper). */
+        ApplyTimeRangeRequested?.Invoke(TimeRangePresets.ForBroadcast(RangePicker.Value, DateTime.UtcNow, GetPickerZone()));
     }
 
     /* The _refreshTimer null guard in both handlers below is doing two jobs. It always absorbed the
@@ -400,6 +408,9 @@ private async void RangePicker_RangeChanged(object? sender, TimeRangeChangedEven
     {
         if (!IsLoaded || _suppressRangeRefresh) return;
 
+        /* L2: a probed floor is the first row inside the window it was probed for, so a held one names an older, shorter window
+           (or an older, longer one) once the range moves. Each page probes again on its own pass. */
+        _probedFloors.Clear();
         PersistSelectedTimeRange(e.Spec);
 
         await RefreshAllDataAsync();
diff --git a/Lite/Helpers/LiteTimeRange.cs b/Lite/Helpers/LiteTimeRange.cs
index 8ffa339fa0..e823ec7cca 100644
--- a/Lite/Helpers/LiteTimeRange.cs
+++ b/Lite/Helpers/LiteTimeRange.cs
@@ -30,6 +30,7 @@ internal static void ConfigureFinOpsPicker(TimeRangePicker picker, TimeSpan unit
     {
         picker.Compact = true;
         picker.RollingUnit = unit;
+        picker.ZoneProvider = () => ServerTimeHelper.CurrentDisplayZone; /* #5562 M1: the tooltip words the range in the zone the grid beside it uses */
     }
 
     /// <summary>The range a fresh install opens on: the old default of four hours.</summary>
@@ -98,20 +99,21 @@ internal static (DateTime startUtc, DateTime? endUtc) BoundsOf(ResolvedTimeRange
     }
 
     /// <summary>
-    /// The longest span Alert History offers (#5562 R8; the old "All" item is gone): a typed length equal to how long Lite keeps
-    /// the alert log, 365 days at most. The alert log is archived like every signal table and its archive files are deleted
-    /// <see cref="RetentionService.ArchiveRetentionMonths"/> months back (RetentionService.cs:34), so on Lite that is 3 months,
-    /// 89 to 92 days at <paramref name="utcNow"/>, rounded up to whole days.
+    /// The longest span Alert History offers (#5562 R8; the old "All" item is gone): 365 days. It covers everything Lite keeps:
+    /// the alert log is archived like every signal table and its archive files are deleted by whole month,
+    /// <see cref="RetentionService.ArchiveRetentionMonths"/> months back, so rows older than 3 months survive until their month's
+    /// file goes, and a 3-month span would hide them. The parser has no year unit, so "1y" cannot be typed; this choice is the way to it.
     /// </summary>
-    internal static TimeSpan AlertHistoryLongest(DateTime utcNow)
-    {
-        var kept = utcNow - utcNow.AddMonths(-RetentionService.ArchiveRetentionMonths);
-        var days = Math.Ceiling(kept.TotalDays);
-        return TimeSpan.FromDays(Math.Min(days, 365));
-    }
+    internal static TimeSpan AlertHistoryLongest { get; } = TimeSpan.FromDays(365);
+
+    /// <summary>The longest choice as the shared control's extra rolling choice (<c>SetLongestChoice</c>), the Viewer's "All" at Lite's reach.</summary>
+    internal static TimeRangeSpec AlertHistoryLongestChoice { get; } = TimeRangeSpec.Relative(AlertHistoryLongest);
 
-    /// <summary>The longest choice as the shared control's extra rolling choice (<c>SetLongestChoice</c>), the Viewer's "All" at Lite's retention.</summary>
-    internal static TimeRangeSpec AlertHistoryLongestChoice(DateTime utcNow) => TimeRangeSpec.Relative(AlertHistoryLongest(utcNow));
+    /// <summary>
+    /// The longest span Job History offers (#5562 R8): 365 days, the old "Last Year", on both desktops. The parser has no year
+    /// unit, so this choice is the only way to a year.
+    /// </summary>
+    internal static TimeRangeSpec JobHistoryLongestChoice { get; } = TimeRangeSpec.Relative(TimeSpan.FromDays(365));
 
     /// <summary>True when <paramref name="range"/> carries its own instants rather than 'the last N hours'.</summary>
     internal static bool HasExplicitInstants(ResolvedTimeRange range) => range.Spec.WholeHours is not > 0;
@@ -131,18 +133,6 @@ internal static TimeRangeSpec FromSettings(string? rangeId, int legacyHours)
         return TimeRangePresets.FromLegacyHours(legacyHours) is { } legacy ? legacy : Default;
     }
 
-    /// <summary>A drill window under the model's 5-minute floor, centred and widened to it; anything longer is returned as it was.</summary>
-    internal static (DateTime fromUtc, DateTime toUtc) AtLeastMinimumSpan(DateTime fromUtc, DateTime toUtc)
-    {
-        if (toUtc - fromUtc >= TimeRangeSpec.MinimumSpan)
-        {
-            return (fromUtc, toUtc);
-        }
-
-        var mid = fromUtc + (toUtc - fromUtc) / 2;
-        return (mid - TimeRangeSpec.MinimumSpan / 2, mid + TimeRangeSpec.MinimumSpan / 2);
-    }
-
     /// <summary>A preset or calendar period persists; a typed fixed or 'since' range does not (a window that ended two days ago is worse than none).</summary>
     internal static bool IsPersistable(TimeRangeSpec spec) =>
         spec.Kind is TimeRangeKind.Relative or TimeRangeKind.Calendar && (spec.Kind != TimeRangeKind.Relative || spec.Span >= TimeRangeSpec.MinimumSpan);
diff --git a/Lite/Services/ServerTimeHelper.cs b/Lite/Services/ServerTimeHelper.cs
index eea988508c..efac07d829 100644
--- a/Lite/Services/ServerTimeHelper.cs
+++ b/Lite/Services/ServerTimeHelper.cs
@@ -87,6 +87,13 @@ public static DateTime ConvertForDisplay(DateTime serverTime, TimeDisplayMode mo
         _ => serverTime
     };
 
+    /// <summary>
+    /// The zone the process-wide display mode shows times in now (#5562): UTC, this machine's zone, or the active server's clock.
+    /// The History tabs and the FinOps pickers read typed times and calendar periods in it, so a picker's "Yesterday" and the
+    /// times the grid prints beside it are the same wall clock. The Viewer's twin is <c>ViewerTimeHelper.CurrentDisplayZone</c>.
+    /// </summary>
+    internal static TimeZoneInfo CurrentDisplayZone => DisplayZoneFor(CurrentDisplayMode, _serverClock);
+
     /// <summary>
     /// The zone a time is shown in for <paramref name="mode"/> (#4766): UTC, this machine's zone, or the server's own
     /// clock (<paramref name="clock"/>: its time zone where one was collected, else its fixed offset). Pure, so a
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
index dd4fd9f1ee..301496937b 100644
--- a/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
@@ -46,9 +46,26 @@ public static class TimeRangePresets
     };
 
     /// <summary>The range the old hour lists meant: 1, 4, 12, 24 and 168 hours, and any other whole number of hours. <c>null</c> for zero or less.</summary>
-    /// <remarks>24 hours is "1d" and 168 is "1w": the same instants, the id the new lists use.</remarks>
+    /// <remarks>24 hours is "1d" and 168 is "1w": the same instants, the id the new lists use. Also <c>null</c> past the 100-year relative limit (#5562 review: a corrupt settings value threw OverflowException).</remarks>
     public static TimeRangeSpec? FromLegacyHours(int hours)
-        => hours <= 0 ? null : TimeRangeSpec.Relative(TimeSpan.FromHours(hours));
+        => hours <= 0 || hours > TimeRangeSpec.MaxRelative.TotalHours ? null : TimeRangeSpec.Relative(TimeSpan.FromHours(hours));
+
+    /// <summary>What "Apply to All" sends for a held range (#5562, M2; Lite and the Viewer share this). A relative range and a fixed or
+    /// since range go as they are (every tab then windows on the same period, as #4766 settled). A calendar period is resolved ONCE
+    /// here, in the source tab's zone, and sent as the instants it names - or as a since range while it still runs (Today) - because
+    /// each tab draws its own server's clock and "Today" would otherwise mean a different day on each. A period that cannot be
+    /// resolved right now goes as it is.</summary>
+    public static TimeRangeSpec ForBroadcast(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
+    {
+        ArgumentNullException.ThrowIfNull(spec);
+        ArgumentNullException.ThrowIfNull(zone);
+        if (spec.Kind != TimeRangeKind.Calendar || !spec.TryResolve(nowUtc, zone, out var range, out _) || range is null)
+        {
+            return spec;
+        }
+
+        return range.IsLive ? TimeRangeSpec.SinceInstant(range.StartUtc) : TimeRangeSpec.FixedRange(range.StartUtc, range.EndUtc);
+    }
 
     /// <summary>The length of a calendar period at <paramref name="nowUtc"/> in <paramref name="zone"/> ("3d", "7h 1m"), or <c>null</c> when the period is shorter than the minimum right now (Today just after midnight).</summary>
     public static string? CurrentLength(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
index 609775da66..decb6c6609 100644
--- a/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
@@ -66,7 +66,7 @@ public sealed record TimeRangeError(string Code, string Message);
 ///
 /// <para>Rules (settled, #5562): relative lengths are real elapsed time; calendar periods use the display zone's
 /// wall-clock boundaries, a boundary being the earliest instant labelled at or after the wall midnight, so
-/// consecutive periods tile with no gap or overlap; no range is shorter than <see cref="MinimumSpan"/>; there is no
+/// consecutive periods tile with no gap or overlap; no typed or relative range is shorter than <see cref="MinimumSpan"/> (a calendar period is exempt: Today at 00:02 reads 00:00 to now); there is no
 /// upper cap here (a tab reads what its data holds).</para>
 /// </summary>
 public sealed class TimeRangeSpec : IEquatable<TimeRangeSpec>
@@ -75,7 +75,7 @@ public sealed class TimeRangeSpec : IEquatable<TimeRangeSpec>
     public static readonly TimeSpan MinimumSpan = TimeSpan.FromMinutes(5);
 
     /// <summary>The longest relative length the model resolves; past it a count is refused as a typing slip.</summary>
-    private static readonly TimeSpan MaxRelative = TimeSpan.FromDays(36500);
+    internal static readonly TimeSpan MaxRelative = TimeSpan.FromDays(36500);
 
     private TimeRangeSpec(TimeRangeKind kind)
     {
@@ -143,7 +143,7 @@ public int? WholeHours
 
     /// <summary>
     /// The instants this range means at <paramref name="nowUtc"/> in <paramref name="zone"/>, or the reason it
-    /// cannot be used (shorter than <see cref="MinimumSpan"/>, ends before it starts, reaches back too far).
+    /// cannot be used (shorter than <see cref="MinimumSpan"/> unless it is a calendar period, ends before it starts, reaches back too far).
     /// </summary>
     public bool TryResolve(DateTime nowUtc, TimeZoneInfo zone, out ResolvedTimeRange? range, out TimeRangeError? error)
     {
@@ -199,7 +199,10 @@ public bool TryResolve(DateTime nowUtc, TimeZoneInfo zone, out ResolvedTimeRange
             return false;
         }
 
-        if (end - start < MinimumSpan)
+        /* A calendar period is exempt from the floor (#5562, seat ruling): "Today" at 00:02 reads 00:00 to now and the "collected
+           every N min" note explains a sparse chart; no other range is ever substituted. The floor applies to typed spans and
+           custom start/end only. A period that has not started (zero length) is still refused. */
+        if (Kind == TimeRangeKind.Calendar ? end <= start : end - start < MinimumSpan)
         {
             error = new TimeRangeError("too_short", ShortMessage(end - start));
             return false;
@@ -263,17 +266,25 @@ public static bool TryFromId(string? id, out TimeRangeSpec? spec)
         }
 
         var unit = text.Substring(unitAt);
-        TimeSpan span;
+        double minutesPerUnit;
         switch (unit)
         {
-            case "m": span = TimeSpan.FromMinutes(count); break;
-            case "h": span = TimeSpan.FromHours(count); break;
-            case "d": span = TimeSpan.FromDays(count); break;
-            case "w": span = TimeSpan.FromDays(7d * count); break;
-            case "mo": span = TimeSpan.FromDays(30d * count); break;
+            case "m": minutesPerUnit = 1d; break;
+            case "h": minutesPerUnit = 60d; break;
+            case "d": minutesPerUnit = 1440d; break;
+            case "w": minutesPerUnit = 7d * 1440d; break;
+            case "mo": minutesPerUnit = 30d * 1440d; break;
             default: return false;
         }
 
+        // #5562 review: a hand-edited settings value like "400000mo" overflowed TimeSpan and threw at startup. A span past the parser's
+        // own limit is not a saved id, so the caller falls back to its default instead of throwing.
+        if (count * minutesPerUnit > MaxRelative.TotalMinutes)
+        {
+            return false;
+        }
+
+        var span = TimeSpan.FromMinutes(count * minutesPerUnit);
         spec = Relative(span);
         return true;
     }

From 254a8b54b1685f3cc1f154095f2016f2d545e9e0 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 12:46:25 -0400
Subject: [PATCH 21/33] CI darling filter reaches
 Lite.Tests/LiteTimeRangeGapTests.cs, which CommentFilterAdoptionTests now
 lists (#5562)

---
 .github/workflows/build.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index da47ea2303..913365947d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -693,6 +693,8 @@ jobs:
               - 'Lite/**/*.csproj'
               # #4966: Darling.Tests' CommentFilterAdoptionTests reads this Lite.Tests file, so an edit to it has to reach the Darling suite.
               - 'Lite.Tests/DataStartBannerQueriesTabTests.cs'
+              # #5562: same, for the Lite.Tests file CommentFilterAdoptionTests lists as a stated bound.
+              - 'Lite.Tests/LiteTimeRangeGapTests.cs'
             # #5459 cut 3a: the part of `darling` that is NOT a Lite file. A diff that reaches `darling` through
             # these (or core, root, a release) runs the whole Darling suite; a diff that reaches it only through the
             # Lite entries above runs the Stage=Guard classes and the classes tagged Reads=Lite, which are the ones

From 25fa2ae7cc13fe856ea7bcd6ed5e26d214675e50 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 12:57:27 -0400
Subject: [PATCH 22/33] Web picker review round 1: Alert History trims to the
 range start, Storage Growth floor, live end, perfmon and heatmap back to 168
 h, reach descriptions pinned (#5562)

---
 .../AlertHistoryRangePageTests.cs             | 15 +++-
 ...FinOpsStorageGrowthWindowBehaviourTests.cs |  5 +-
 Darling/Darling.Tests/WebPageRangeTests.cs    |  6 +-
 .../Darling.Tests/WebReadReachLiveTests.cs    | 17 +++-
 Darling/Darling.Tests/WebReadReachTests.cs    | 83 ++++++++++++++++++-
 Darling/Darling.Tests/WebTimeRangeTests.cs    | 18 +++-
 .../alert-history-advice-harness.mjs          |  3 +-
 .../alert-history-dismiss-harness.mjs         |  3 +-
 .../alert-history-range-harness.mjs           | 12 ++-
 .../finops-storage-growth-window-harness.mjs  |  2 +-
 .../time-range-picker-harness.mjs             | 24 +++++-
 .../DarlingFleetSweepEndpoints.cs             |  6 +-
 .../Mcp/DarlingMcpQueryHeatmapTools.cs        |  7 +-
 .../Mcp/DarlingMcpTrendTools.cs               |  7 +-
 .../WebReadReach.cs                           | 12 +--
 .../wwwroot/js/page-range.js                  | 35 ++++++--
 .../wwwroot/js/pages/alerts.js                | 43 +++++++---
 .../wwwroot/js/pages/finops/storage-growth.js |  4 +-
 .../wwwroot/js/pages/job-history.js           | 15 +++-
 .../wwwroot/js/pages/server.js                | 13 ++-
 .../wwwroot/js/time-range-picker.js           | 35 +++++---
 .../wwwroot/js/time-range.js                  | 15 ++--
 PerformanceMonitor.Common/Mcp/McpHelpers.cs   |  4 +-
 23 files changed, 310 insertions(+), 74 deletions(-)

diff --git a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
index 78ac40bbb0..5a2b95169c 100644
--- a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
+++ b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
@@ -32,7 +32,7 @@ public void ThePageReadsGetAlertHistoryWithTheFourChoicesAndNeverAFixedWindow()
         var page = Page();
         Assert.DoesNotContain("hours_back: 24", page);
         Assert.DoesNotContain("limit: 200 }", page);
-        Assert.Contains("readTool(\"get_alert_history\", readParams())", page);
+        Assert.Contains("readTool(\"get_alert_history\", req.params)", page);
         // #5562: the range is the shared picker's spec, read as of each read; a finished range also sends its end.
         Assert.Contains("const w = windowOfSpec(choices.spec);", page);
         Assert.Contains("hours_back: w ? w.hours : DEFAULT_HOURS", page);
@@ -127,7 +127,7 @@ public void EachChoiceReachesTheRead()
         Assert.Equal("srv-b", Get(dismissed, "server_name"));
 
         // The popup offers every preset and calendar period within the catalog's 90 days; the longer ones are greyed out, never clamped.
-        Assert.Equal("Past 5 minutes,Past 15 minutes,Past 30 minutes,Past hour,Past 4 hours,Past day,Past 2 days,Past week,Past 30 days,Today,Yesterday,Week to Date,Previous Week,Month to Date,Previous Month",
+        Assert.Equal("Past 5 minutes,Past 15 minutes,Past 30 minutes,Past hour,Past 4 hours,Past day,Past 2 days,Past week,Past 30 days,Past 90 days,Today,Yesterday,Week to Date,Previous Week,Month to Date,Previous Month",
             string.Join(",", r.GetProperty("windowOptions").EnumerateArray().Select(e => e.GetString())));
         Assert.Equal("Year to Date,Previous Year",
             string.Join(",", r.GetProperty("windowGreyed").EnumerateArray().Select(e => e.GetString())));
@@ -217,6 +217,17 @@ public void ANewWindowReconcilesInPlace_RowsLeaveAndNewOnesLandInOrder()
         Assert.Equal("High CPU 3", string.Join(",", r.GetProperty("shrunk").EnumerateArray().Select(e => e.GetString())));
     }
 
+    [Fact]
+    public void ARangeShorterThanTheWholeHoursItFetches_ListsOnlyTheAlertsInsideIt()
+    {
+        var r = Run("trim");
+        string[] Names(string key) => r.GetProperty(key).EnumerateArray().Select(e => e.GetString()!).ToArray();
+        Assert.Equal(new[] { "High CPU 0", "High CPU 19", "High CPU 89" }, Names("day"));
+        Assert.Equal(new[] { "High CPU 0" }, Names("fiveMinutes"));
+        Assert.Equal(new[] { "High CPU 0", "High CPU 19" }, Names("thirtyMinutes"));
+        Assert.Equal(new[] { "High CPU 0", "High CPU 19", "High CPU 89" }, Names("fourHours"));
+    }
+
     [Fact]
     public void TheMuteLinksStillRenderOnEveryRow()
     {
diff --git a/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs b/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
index 02454ee9e0..39c19a59e2 100644
--- a/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
+++ b/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
@@ -85,11 +85,14 @@ public void TheObjectsLevelDefaultsToThirtyDays_AndEachPickSendsDaysTimes24()
         var objects = run.GetProperty("objects");
         Assert.Equal(new[] { "720" }, Hours(objects));
         // #5562 R5: the Compact rolling-only picker, whole days, reach 2160 hours for this view (not the catalog entry's 168).
-        Assert.Equal("Past day,Past 2 days,Past week,Past 30 days", string.Join(",", objects.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
+        Assert.Equal("Past week,Past 30 days", string.Join(",", objects.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
         var refused = objects.GetProperty("refused");
         Assert.Equal("This page reads whole days back from now, such as 7d or 30d.", refused.GetProperty("hours").GetString());
         Assert.Equal("This page reads a length back from now, so pick a rolling length such as 24h or 7d.", refused.GetProperty("calendar").GetString());
         Assert.Equal("This page's reads reach at most 90 days back.", refused.GetProperty("tooLong").GetString());
+        /* Review r1 H1: 1 day would read the server's 30-day default and 2 to 6 days are refused by the read, so neither is offered. */
+        Assert.Equal("This page reads at least 7d back from now.", refused.GetProperty("tooShort").GetString());
+        Assert.Equal("This page reads at least 7d back from now.", refused.GetProperty("oneDay").GetString());
         Assert.Equal("Past 30 days", objects.GetProperty("value").GetString());
 
         Assert.Equal(new[] { "2160" }, Hours(run.GetProperty("picked90")));
diff --git a/Darling/Darling.Tests/WebPageRangeTests.cs b/Darling/Darling.Tests/WebPageRangeTests.cs
index 4aa863c330..bfb76ae95d 100644
--- a/Darling/Darling.Tests/WebPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebPageRangeTests.cs
@@ -88,7 +88,7 @@ public void TheStorageGrowthPickerTakesTheViewsOwnReachAndWholeDays()
         Assert.DoesNotContain("STORAGE_GROWTH_REACH_HOURS", src);
         Assert.Contains("view: \"storage_growth\",", src);
         Assert.Contains("view_max_hours", Js("page-range.js"));
-        Assert.Contains("minSpanMs: DAY_MS,", src);
+        Assert.Contains("minSpanMs: 7 * DAY_MS,", src);
         Assert.Contains("stepMs: DAY_MS,", src);
 
         // The reach is the view's, as the tool's own description says; the get_finops catalog entry says 168 for its other views.
@@ -153,7 +153,9 @@ public void TheServerPageGivesThePickerTheTabsActualCollectorInterval_AndNeverWi
         Assert.Contains("serverCatalog(server).then((catalog) => {", server);
         Assert.Contains("picker.setSampleInterval(collectorIntervalFromCatalog(catalog, tab.collector));", server);
         // The note is set before the keep-the-panels return, so a poll that keeps the grid still gets it.
-        Assert.True(server.IndexOf("  applySampleNote();", StringComparison.Ordinal) < server.IndexOf("if (keepGrid) {", StringComparison.Ordinal));
+        var noteCall = server.IndexOf("  applySampleNote();", StringComparison.Ordinal);
+        Assert.True(noteCall >= 0, "server.js no longer calls applySampleNote().");
+        Assert.True(noteCall < server.IndexOf("if (keepGrid) {", StringComparison.Ordinal));
         // The server's own schedule: the catalog is asked for this server.
         Assert.Contains("\"/api/catalog?server=\" + encodeURIComponent(server)", Js("page-range.js"));
     }
diff --git a/Darling/Darling.Tests/WebReadReachLiveTests.cs b/Darling/Darling.Tests/WebReadReachLiveTests.cs
index 1bd0fe9029..9d046a0ba8 100644
--- a/Darling/Darling.Tests/WebReadReachLiveTests.cs
+++ b/Darling/Darling.Tests/WebReadReachLiveTests.cs
@@ -139,13 +139,26 @@ await DarlingMcpTestData.ExecAsync(connection, ct,
             }
 
             /* The raw-table trends reach their table's 30 days (#5562 L4b): 720 is answered, 721 is refused, never clamped. */
-            foreach (var read in new[] { "get_tempdb_trend", "get_query_heatmap", "get_cpu_utilization" })
+            foreach (var read in new[] { "get_tempdb_trend", "get_memory_trend", "get_cpu_utilization" })
             {
-                Assert.DoesNotContain("exceeds maximum", await WebReadAsync(postgres, read, WebReadReach.RawTrendHours));
+                /* No "error" key at all, not merely a message without the ceiling text: a read that failed for another reason must not pass (review L6). */
+                var answered = await WebReadAsync(postgres, read, WebReadReach.RawTrendHours);
+                using (var answeredDoc = JsonDocument.Parse(answered))
+                {
+                    Assert.False(answeredDoc.RootElement.TryGetProperty("error", out _), $"{read} refused its own declared reach: {answered}");
+                }
+
                 var refused = McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, read, WebReadReach.RawTrendHours + 1));
                 Assert.Contains("exceeds maximum of 720 hours (30 days)", refused);
             }
 
+            /* Raised-then-lowered (#5562 review r1): the perfmon trend (11.2 s cold at 30 days, #5574) and the heatmap (raw query_stats, four days on a TimescaleDB store) stay at 168. */
+            foreach (var read in new[] { "get_perfmon_trend", "get_query_heatmap" })
+            {
+                Assert.Contains("exceeds maximum of 168 hours (7 days)",
+                    McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, read, McpHelpers.MaxHoursBack + 1)));
+            }
+
             bodySucceeded = true;
         }
         finally
diff --git a/Darling/Darling.Tests/WebReadReachTests.cs b/Darling/Darling.Tests/WebReadReachTests.cs
index d6a3cf1738..973d999dfa 100644
--- a/Darling/Darling.Tests/WebReadReachTests.cs
+++ b/Darling/Darling.Tests/WebReadReachTests.cs
@@ -102,14 +102,93 @@ public void OnlyBucketedTrends_ReachPastTheDefault_AndNoneReachesPastTheirRollup
             new[]
             {
                 "get_alert_history", "get_blocking_stats", "get_blocking_trend", "get_cpu_utilization", "get_deadlock_trend", "get_file_io_trend",
-                "get_lock_wait_trend", "get_memory_trend", "get_perfmon_trend", "get_pg_cpu_utilization", "get_pg_database_trend", "get_pg_io_trend",
-                "get_procedure_duration_trend", "get_query_duration_trend", "get_query_heatmap", "get_query_store_duration_trend", "get_tempdb_trend",
+                "get_lock_wait_trend", "get_memory_trend", "get_pg_cpu_utilization", "get_pg_database_trend", "get_pg_io_trend",
+                "get_procedure_duration_trend", "get_query_duration_trend", "get_query_store_duration_trend", "get_tempdb_trend",
                 "get_wait_trend",
             },
             WebReadReach.All.Where(kv => kv.Value.MaxHours > McpHelpers.MaxHoursBack).Select(kv => kv.Key).OrderBy(n => n, StringComparer.Ordinal).ToArray());
         Assert.Equal(2160, WebReadReach.RollupTrendHours);
         Assert.Equal(720, WebReadReach.RawTrendHours);
         Assert.Equal(2160, WebReadReach.AlertHistoryHours);
+
+        /* Review r1: get_perfmon_trend (11.2 s cold at 30 days, #5574) and get_query_heatmap (raw query_stats, four days on a TimescaleDB store) stay at a week. */
+        Assert.Equal(McpHelpers.MaxHoursBack, WebReadReach.MaxHoursFor("get_perfmon_trend"));
+        Assert.Equal(McpHelpers.MaxHoursBack, WebReadReach.MaxHoursFor("get_query_heatmap"));
+    }
+
+    /// <summary>
+    /// Review r1 M1: a read's reach never exceeds its table's retention on EITHER store type. The test above checks the
+    /// collector's default retention (plain PostgreSQL); a TimescaleDB store drops the three raw tiers at four days. A read of
+    /// one of those raw tables (not a rollup-routed trend, whose reach is the rollup's) stays at <see cref="McpHelpers.MaxHoursBack"/>
+    /// or less, and the four days is named so a change to it surfaces here.
+    /// </summary>
+    [Fact]
+    public void NoRawTierTableRead_ReachesPastTheTimescaleRawRetention()
+    {
+        Assert.Equal("4 days", PerformanceMonitor.Darling.Storage.TimescaleSupport.RawRetentionInterval);
+        var rawTierTables = PerformanceMonitor.Darling.Storage.TimescaleSupport.RawRelations.ToHashSet(StringComparer.Ordinal);
+        foreach (var (read, reach) in WebReadReach.All)
+        {
+            if (reach.Collector is null || reach.MaxHours == WebReadReach.RollupTrendHours)
+            {
+                continue;
+            }
+
+            var table = CollectorCatalog.All.SingleOrDefault(c => c.Name == reach.Collector)?.TargetTable;
+            if (table is not null && rawTierTables.Contains(table))
+            {
+                Assert.True(
+                    reach.MaxHours <= McpHelpers.MaxHoursBack,
+                    $"{read} reads raw {table}, which a TimescaleDB store drops after four days, but reaches {reach.MaxHours} h.");
+            }
+        }
+    }
+
+    /// <summary>
+    /// Review r1 M6: the <c>hours_back</c> description of every MCP tool carries the number its <see cref="WebReadReach"/> row
+    /// holds, so raising or lowering a row cannot leave the description stating the old ceiling. A tool that never capped
+    /// (<c>ValidateUncappedWindow</c>) states no ceiling and is skipped; a tool whose row stays at the default states none either.
+    /// </summary>
+    [Fact]
+    public void EveryRaisedTool_HoursBackDescription_NamesItsRowsNumber_AndNoOtherToolClaimsAHigherOne()
+    {
+        var tools = typeof(WebReadReach).Assembly.GetTypes()
+            .SelectMany(t => t.GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic))
+            .Select(m => (Method: m, Attr: (ModelContextProtocol.Server.McpServerToolAttribute?)Attribute.GetCustomAttribute(m, typeof(ModelContextProtocol.Server.McpServerToolAttribute))))
+            .Where(x => x.Attr?.Name is not null)
+            .ToDictionary(x => x.Attr!.Name!, x => x.Method, StringComparer.Ordinal);
+        var uncapped = new[] { "get_blocking_stats" };
+        var raised = 0;
+        foreach (var (read, reach) in WebReadReach.All)
+        {
+            if (!tools.TryGetValue(read, out var method))
+            {
+                continue;
+            }
+
+            var hoursBack = method.GetParameters().SingleOrDefault(p => p.Name == "hours_back");
+            var description = hoursBack is null ? null
+                : ((System.ComponentModel.DescriptionAttribute?)Attribute.GetCustomAttribute(hoursBack, typeof(System.ComponentModel.DescriptionAttribute)))?.Description;
+            if (description is null || Array.IndexOf(uncapped, read) >= 0)
+            {
+                continue;
+            }
+
+            var claim = Regex.Match(description, @"up to (?<n>\d+)");
+            if (reach.MaxHours > McpHelpers.MaxHoursBack)
+            {
+                raised++;
+                Assert.True(claim.Success && claim.Groups["n"].Value == reach.MaxHours.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                    $"{read}: hours_back says '{description}' but its WebReadReach row holds {reach.MaxHours}.");
+            }
+            else if (claim.Success)
+            {
+                Assert.True(int.Parse(claim.Groups["n"].Value, System.Globalization.CultureInfo.InvariantCulture) <= reach.MaxHours,
+                    $"{read}: hours_back says '{description}' but its WebReadReach row holds only {reach.MaxHours}.");
+            }
+        }
+
+        Assert.True(raised >= 14, $"Only {raised} raised tools had an hours_back description to check; the reflection missed them.");
     }
 
     /// <summary>
diff --git a/Darling/Darling.Tests/WebTimeRangeTests.cs b/Darling/Darling.Tests/WebTimeRangeTests.cs
index 920cd7c55d..d97e831fac 100644
--- a/Darling/Darling.Tests/WebTimeRangeTests.cs
+++ b/Darling/Darling.Tests/WebTimeRangeTests.cs
@@ -215,10 +215,23 @@ public void ThePresetsAndThePick_ApplyHoldAndPreview()
         var picked = r.GetProperty("picked");
         Assert.Equal("2026-10-01 13:00 - 2026-10-01 15:00", picked.GetProperty("text").GetString());
         Assert.Equal("2h  Oct 1, 1:00 pm - Oct 1, 3:00 pm (UTC-04:00)", picked.GetProperty("preview").GetString());
+
+        // Review r1 M3: moving only the start of a live range leaves the end as "now", so the range keeps refreshing; typing an end fixes it.
+        var liveEnd = r.GetProperty("liveEnd");
+        Assert.Equal("2026-10-08 05:00 - now", liveEnd.GetProperty("startOnly").GetString());
+        Assert.Equal("2026-10-08 05:00 - 2026-10-08 07:00", liveEnd.GetProperty("edited").GetString());
+
+        // Review r1 M2: an end at or after now is a live range ending now (no as_of); one in the past keeps its as_of.
+        var futureEnd = r.GetProperty("futureEnd");
+        Assert.True(futureEnd.GetProperty("future").GetProperty("live").GetBoolean());
+        Assert.Equal(JsonValueKind.Null, futureEnd.GetProperty("future").GetProperty("asOf").ValueKind);
+        Assert.Equal(3, futureEnd.GetProperty("future").GetProperty("hours").GetInt32());
+        Assert.False(futureEnd.GetProperty("past").GetProperty("live").GetBoolean());
+        Assert.NotEqual(JsonValueKind.Null, futureEnd.GetProperty("past").GetProperty("asOf").ValueKind);
     }
 
-    /// <summary>Compact moves the detail into the tooltip; the sample-interval note shows when the span holds fewer than three samples
-    /// and the data-start note when the range starts well before the data; select() refuses a range the page cannot take; the catalog's
+    /// <summary>Compact moves the detail into the tooltip; the sample-interval note shows when the span holds fewer than three samples;
+    /// select() refuses a range the page cannot take; the catalog's
     /// max_hours is the reach; a live range slides on refresh.</summary>
     [Fact]
     public void TheNotesTheReachAndTheClock_FollowTheirInputs()
@@ -228,7 +241,6 @@ public void TheNotesTheReachAndTheClock_FollowTheirInputs()
         Assert.Equal(string.Empty, r.GetProperty("compact").GetProperty("detail").GetString());
         Assert.Equal("Past day, Oct 7, 7:01 am - Oct 8, 7:01 am (UTC-04:00)", r.GetProperty("compact").GetProperty("title").GetString());
         Assert.Equal("Data here is collected every 5 minutes.", r.GetProperty("notes").GetProperty("short").GetString());
-        Assert.Equal("Data starts Oct 8, 5:01 am", r.GetProperty("notes").GetProperty("wide").GetString());
 
         var select = r.GetProperty("select");
         Assert.Contains("7 days", select.GetProperty("tooLong").GetString());
diff --git a/Darling/Darling.Tests/alert-history-advice-harness.mjs b/Darling/Darling.Tests/alert-history-advice-harness.mjs
index dc1d222bec..dd41b5ae10 100644
--- a/Darling/Darling.Tests/alert-history-advice-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-advice-harness.mjs
@@ -81,8 +81,9 @@ globalThis.fetch = async (url, init) => {
 const detailReadsOf = () => urls.filter((u) => u.includes("/get_alert_details")).map((u) => Object.fromEntries(new URL(u, "http://x").searchParams));
 const readsOf = () => urls.filter((u) => u.includes("/get_alert_history")).map((u) => Object.fromEntries(new URL(u, "http://x").searchParams));
 
+const T0 = Date.now();
 const row = (i, over = {}) => ({
-  alert_time: new Date(Date.UTC(2026, 0, 1, 12, 0, 0) - i * 60000).toISOString(),
+  alert_time: new Date(T0 - 60000 - i * 60000).toISOString(),
   server_id: 1, server_name: "srv-a", stored_server_name: "srv-a", metric_name: "High CPU " + i,
   current_value: 90, threshold_value: 80, severity: "warning", severity_source: "fired", dismissed: false, ...over,
 });
diff --git a/Darling/Darling.Tests/alert-history-dismiss-harness.mjs b/Darling/Darling.Tests/alert-history-dismiss-harness.mjs
index b959925da1..27710e04dd 100644
--- a/Darling/Darling.Tests/alert-history-dismiss-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-dismiss-harness.mjs
@@ -75,8 +75,9 @@ globalThis.fetch = async (url, init) => {
 };
 const readsOf = () => urls.filter((u) => u.includes("/get_alert_history")).map((u) => Object.fromEntries(new URL(u, "http://x").searchParams));
 
+const T0 = Date.now();
 const row = (i, over = {}) => ({
-  alert_time: new Date(Date.UTC(2026, 0, 1, 12, 0, 0) - i * 60000).toISOString(),
+  alert_time: new Date(T0 - 60000 - i * 60000).toISOString(),
   server_id: 1, server_name: "srv-a", stored_server_name: "srv-a", metric_name: "High CPU " + i,
   current_value: 90, threshold_value: 80, severity: "warning", severity_source: "fired", dismissed: false, ...over,
 });
diff --git a/Darling/Darling.Tests/alert-history-range-harness.mjs b/Darling/Darling.Tests/alert-history-range-harness.mjs
index 6971150de9..c23c01363a 100644
--- a/Darling/Darling.Tests/alert-history-range-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-range-harness.mjs
@@ -60,8 +60,9 @@ globalThis.fetch = async (url) => {
 };
 const readsOf = () => urls.filter((u) => u.includes("/get_alert_history")).map((u) => Object.fromEntries(new URL(u, "http://x").searchParams));
 
+const T0 = Date.now();
 const row = (i, over = {}) => ({
-  alert_time: new Date(Date.UTC(2026, 0, 1, 12, 0, 0) - i * 60000).toISOString(),
+  alert_time: new Date(T0 - 60000 - i * 60000).toISOString(),
   server_id: 1, server_name: "srv-a", stored_server_name: "srv-a", metric_name: "High CPU " + i,
   current_value: 90, threshold_value: 80, severity: "warning", severity_source: "fired", dismissed: false, ...over,
 });
@@ -183,6 +184,15 @@ try {
       pickRange(main, "Time range", "1h"); await settle();
       out.shrunk = metrics(main);
     },
+    async trim() {
+      // Review r1 H2: the read takes whole hours, so a 5 or 30 minute range lists only the alerts inside it. Rows are 1, 20 and 90 minutes old.
+      alertsReply = { alerts: [row(0), row(19), row(89)], truncated: false };
+      const main = newMain(); await renderAlerts(main);
+      out.day = metrics(main);
+      pickRange(main, "Time range", "5m"); await settle(); out.fiveMinutes = metrics(main);
+      pickRange(main, "Time range", "30m"); await settle(); out.thirtyMinutes = metrics(main);
+      pickRange(main, "Time range", "4h"); await settle(); out.fourHours = metrics(main);
+    },
     async mute() {
       alertsReply = { alerts: [row(1)], truncated: false };
       const main = newMain(); await renderAlerts(main);
diff --git a/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs b/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
index d1c0f2e52b..42c8baff01 100644
--- a/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
+++ b/Darling/Darling.Tests/finops-storage-growth-window-harness.mjs
@@ -118,7 +118,7 @@ try {
     options: pickerItems(root, "Window").filter((i) => !i.disabled).map((i) => i.name),
     disabled: pickerItems(root, "Window").filter((i) => i.disabled).map((i) => i.name + ": " + i.why),
     value: pickerText(root, "Window"),
-    refused: { hours: pickRange(root, "Window", "36h"), calendar: pickRange(root, "Window", "last month"), tooLong: pickRange(root, "Window", "120d") },
+    refused: { hours: pickRange(root, "Window", "200h"), calendar: pickRange(root, "Window", "last month"), tooLong: pickRange(root, "Window", "120d"), tooShort: pickRange(root, "Window", "3d"), oneDay: pickRange(root, "Window", "1d") },
   };
 
   // Pick 90 days, then 7 days: each re-reads with days * 24.
diff --git a/Darling/Darling.Tests/time-range-picker-harness.mjs b/Darling/Darling.Tests/time-range-picker-harness.mjs
index 0bc4241a21..1b0c294815 100644
--- a/Darling/Darling.Tests/time-range-picker-harness.mjs
+++ b/Darling/Darling.Tests/time-range-picker-harness.mjs
@@ -230,8 +230,7 @@ const found = {};
   const detail = byClass(compact.p.node, "trp-detail")[0];
   found.compact = { detail: text(detail), title: compact.p.node.attrs.title };
   const shortOne = make({ spec: tr.relativeSpec(5 * 60000), sampleIntervalMs: 5 * 60000 });
-  const wide = make({ spec: tr.relativeSpec(4 * 3600000), sampleIntervalMs: 5 * 60000, dataStartMs: NOW - 2 * 3600000 });
-  found.notes = { short: text(byClass(shortOne.p.node, "trp-note")[0]), wide: text(byClass(wide.p.node, "trp-note")[0]) };
+  found.notes = { short: text(byClass(shortOne.p.node, "trp-note")[0]) };
   const m = make();
   found.select = { tooLong: m.p.select(tr.relativeSpec(30 * 86400000)), tooShort: m.p.select(tr.relativeSpec(60000)), ok: m.p.select(tr.relativeSpec(3600000)), changes: m.changes.map((c) => c.id) };
 }
@@ -258,4 +257,25 @@ const found = {};
   found.slides = { first, second, afterSetSpec: text(button), specId: tr.specId(p.spec()) };
 }
 
+/* 12. Review r1 M3: on a live range, editing only the start box keeps the end as "now"; typing an end makes it a fixed pair. */
+{
+  const { root, button, p } = make({ spec: tr.relativeSpec(4 * 3600000) });
+  fire(button, "click");
+  const [from, to] = byClass(root, "trp-pick");
+  const original = from.value;
+  from.value = "2026-10-08T05:00";
+  fire(from, "change");
+  const startOnly = byClass(root, "trp-text")[0].value;
+  to.value = "2026-10-08T07:00";
+  fire(to, "change");
+  found.liveEnd = { original, startOnly, edited: byClass(root, "trp-text")[0].value };
+}
+
+/* 13. Review r1 M2: a fixed range whose end is at or after now is a live range ending now (no as_of); one that has ended keeps its as_of. */
+{
+  const { p } = make({ spec: tr.fixedSpec(NOW - 3 * 3600000, NOW + 3600000) });
+  const past = make({ spec: tr.fixedSpec(NOW - 3 * 3600000, NOW - 3600000) });
+  found.futureEnd = { future: p.window(), past: past.p.window() };
+}
+
 console.log(JSON.stringify(found));
diff --git a/Darling/PerformanceMonitor.Darling.Service/DarlingFleetSweepEndpoints.cs b/Darling/PerformanceMonitor.Darling.Service/DarlingFleetSweepEndpoints.cs
index 30d13b8d38..4ce625d114 100644
--- a/Darling/PerformanceMonitor.Darling.Service/DarlingFleetSweepEndpoints.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/DarlingFleetSweepEndpoints.cs
@@ -97,10 +97,12 @@ internal static class DarlingFleetSweepEndpoints
         if (rawHours is not null
             && !int.TryParse(rawHours, NumberStyles.Integer, CultureInfo.InvariantCulture, out hours))
         {
-            return McpHelpers.Refusal("hours", $"Invalid hours value '{rawHours}'. Expected a whole number of hours (1-{McpHelpers.MaxHoursBack}).");
+            return McpHelpers.Refusal("hours", $"Invalid hours value '{rawHours}'. Expected a whole number of hours (1-{WebReadReach.All["get_sweep_reports"].MaxHours}).");
         }
 
-        return McpHelpers.ValidateWindow(hours, asOf, out endUtc);
+        /* The ceiling is get_sweep_reports' WebReadReach row, the number the sweeps page reads from the catalog, so the page and this
+           endpoint share one source (#5562 review r1 L7). The row stays at the default, so this is not an opted-in validator. */
+        return McpHelpers.ValidateWindow(hours, asOf, WebReadReach.All["get_sweep_reports"].MaxHours, out endUtc);
     }
 
     /// <summary>
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs
index ec9c33e132..fb630a835c 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpQueryHeatmapTools.cs
@@ -62,7 +62,7 @@ public sealed class DarlingMcpQueryHeatmapTools
     public static Task<string> GetQueryHeatmap(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("How far back to look, in hours. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("How far back to look, in hours. Default 24.")] int hours_back = 24,
         [Description("Which per-execution metric to bucket by: duration, cpu, logical_reads, logical_writes or execution_count. Default duration.")] string? metric = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
         [Description("Width of each time bin, in minutes. Default 5 - the desktop viewer's own bin width, so the two surfaces agree. Raise it to cover a longer window in fewer cells.")] int bucket_minutes = DarlingQueryHeatmapReader.ViewerBucketMinutes,
@@ -98,8 +98,9 @@ internal static async Task<string> GetQueryHeatmap(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        /* #5562: reaches the raw table's 30-day retention (720 h); 5.5 s at 30 days on a large store. The ceiling is the WebReadReach row. */
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_query_heatmap"), out var windowEnd)
+        /* #5562: stays at 168 h. This reads raw query_stats, which a TimescaleDB store drops at four days (TimescaleSupport.RawRetentionInterval), so a
+           longer reach would be a window the table cannot fill, so this keeps the 168-hour overload (its WebReadReach row says the same). */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd)
             ?? McpHelpers.ValidateTop(limit);
         if (validation != null) return validation;
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
index 76d91e5253..dba5f24dbc 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
@@ -172,7 +172,7 @@ public static Task<string> GetPerfmonTrend(
         NpgsqlDataSource postgres,
         [Description("The exact counter name, e.g. 'Batch Requests/sec'.")] string counter_name,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -187,8 +187,9 @@ internal static async Task<string> GetPerfmonTrend(
         var (resolved, error) = await DarlingServerResolver.ResolveOrErrorAsync(postgres, server_name, cancellationToken);
         if (error != null) return error;
 
-        /* #5562: reaches the raw table's 30-day retention (720 h). The 12.5 s at 30 days came from the Wait Statistics arm's right(object_name, 16) filter, which
-           decompressed and dropped every row; DarlingTrendReader.PerfmonTrendSql now filters with LIKE, which the columnar scan vectorizes. */
+        /* #5562: stays at 168 h. The re-time on a large store read 11.2 s cold at 30 days even with the LIKE predicate (DarlingTrendReader.PerfmonTrendSql,
+           which saved 1.3 s cold): the compressed perfmon_stats data is grouped by server only, so the read decodes every counter's name no matter which
+           counter was asked for. A month is too slow to offer (#5574 tracks compressing the data by counter so it can reach 30 days); the ceiling is the WebReadReach row. */
         var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_perfmon_trend"), out var windowEnd);
         if (validation != null) return validation;
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
index 4e59caa35e..cc35c7e0aa 100644
--- a/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/WebReadReach.cs
@@ -58,7 +58,7 @@ internal sealed record ReadReach(ReadShape Shape, int MaxHours, string? Collecto
 /// (<c>RetentionTierRouter.ClampToTextHorizon</c>), and none of the three opted-in reads carries either.
 /// The raw-table bucketed trends reach <see cref="RawTrendHours"/> (30 days, the raw tables' default retention) once a
 /// timing run on a large store measured a month under 10 seconds (#5562 L4b); a trend not yet timed, or over a table
-/// that keeps less than 30 days, stays at 168 hours. Raising one is a one-line change to its row here, plus its
+/// that keeps less than 30 days on EITHER store type (plain PostgreSQL, or the raw tier a TimescaleDB store drops at four days), stays at 168 hours. Raising one is a one-line change to its row here, plus its
 /// validator call, and nothing else. Alert History is the one list that reaches past a week (ruling R8): its reach is
 /// the alert table's retention, <see cref="AlertHistoryHours"/>, and the read is capped by its row limit.</para>
 /// </summary>
@@ -109,21 +109,23 @@ internal static class WebReadReach
 
         /* Raw-table bucketed trends: 720 hours where the large-store timing run measured a month under 10 s (#5562 L4b;
            each validator names its time). Left at 168: get_current_waits_trend (its waiting_tasks table keeps 7 days),
-           get_server_trend (6 of its 11 metrics were never timed), get_pg_wait_trend (its timing table was empty) and
-           get_pg_query_duration_trend (not timed). get_blocking_stats is uncapped on the MCP side (ValidateUncappedWindow). */
+           get_server_trend (6 of its 11 metrics were never timed), get_pg_wait_trend (its timing table was empty),
+           get_pg_query_duration_trend (not timed), get_perfmon_trend (11.2 s cold at 30 days on a large store: the compressed data is
+           grouped by server only, so the read decodes every counter's name; #5574 tracks the fix) and get_query_heatmap (raw query_stats, which a TimescaleDB
+           store drops at four days, so a month is a window the table cannot fill). get_blocking_stats is uncapped on the MCP side (ValidateUncappedWindow). */
         ["get_blocking_trend"] = Trend("blocked_process_report", RawTrendHours),
         ["get_deadlock_trend"] = Trend("deadlocks", RawTrendHours),
         ["get_lock_wait_trend"] = Trend("wait_stats", RawTrendHours),
         ["get_current_waits_trend"] = Trend("waiting_tasks"),
         ["get_blocking_stats"] = Trend("dmv_blocking_snapshot", RawTrendHours),
         ["get_cpu_utilization"] = Trend("cpu_utilization", RawTrendHours),
-        ["get_query_heatmap"] = Trend("query_stats", RawTrendHours),
+        ["get_query_heatmap"] = Trend("query_stats"),
         ["get_tempdb_trend"] = Trend("tempdb_stats", RawTrendHours),
         ["get_wait_trend"] = Trend("wait_stats", RawTrendHours),
         ["get_file_io_trend"] = Trend("file_io_stats", RawTrendHours),
         ["get_memory_trend"] = Trend("memory_stats", RawTrendHours),
         ["get_server_trend"] = Trend(null),
-        ["get_perfmon_trend"] = Trend("perfmon_stats", RawTrendHours),
+        ["get_perfmon_trend"] = Trend("perfmon_stats"),
         ["get_pg_cpu_utilization"] = Trend("pg_cpu_utilization", RawTrendHours),
         ["get_pg_wait_trend"] = Trend("pg_wait_sampling"),
         ["get_pg_query_duration_trend"] = Trend("pg_statement_stats"),
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
index d0e021f70f..c1663925fd 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
@@ -21,10 +21,13 @@
  */
 
 import { timeRangePicker } from "./time-range-picker.js";
-import { reachHours, collectorIntervalMs, resolveSpec, readWindow, browserZone, relativeSpec } from "./time-range.js";
+import { reachHours, collectorIntervalMs, resolveSpec, readWindow, browserZone, relativeSpec, ROLLING_PRESETS } from "./time-range.js";
 import { getCatalog } from "./views-api.js";
 import { apiGet } from "./util.js";
 
+const HOUR_MS = 3600000;
+const SERVER_CATALOG_TTL_MS = 5 * 60000;
+
 const serverCatalogs = new Map();
 
 /** The window a read takes for a held spec as of now: `{ hours, asOf, live, startMs, endMs }`, or null when the spec cannot be resolved
@@ -32,7 +35,14 @@ const serverCatalogs = new Map();
  *  it) calls this on every read, so a live range slides with the clock. */
 export function windowOfSpec(spec, nowMs = Date.now(), zone = browserZone()) {
   const r = resolveSpec(spec, nowMs, zone);
-  return r.ok ? readWindow(r.range) : null;
+  return r.ok ? readWindow(r.range, nowMs) : null;
+}
+
+/** Like windowOfSpec, but says why a spec cannot be read: `{ window }` or `{ error: message }`. A page shows the message (a Today range
+ *  in its first five minutes) instead of quietly reading a different window (#5562 review r1 L3). */
+export function windowResultOfSpec(spec, nowMs = Date.now(), zone = browserZone()) {
+  const r = resolveSpec(spec, nowMs, zone);
+  return r.ok ? { window: readWindow(r.range, nowMs) } : { error: r.error.message };
 }
 
 /** One catalog entry by read name from the fleet-wide catalog, or null. */
@@ -44,10 +54,14 @@ export async function catalogEntryFor(read) {
 /** The catalog with the SERVER's own collector intervals (a per-server schedule row wins), cached per server. Null when it cannot be read. */
 export function serverCatalog(server) {
   if (!serverCatalogs.has(server)) {
-    serverCatalogs.set(
-      server,
-      apiGet("/api/catalog?server=" + encodeURIComponent(server)).then((r) => (r.kind === "data" && r.data ? r.data : null))
-    );
+    /* Only a catalog that was read is kept (#5562 review r1 L2): a failed fetch is not cached as null for the page's life, and a
+       schedule edited in Settings is seen again after the entry expires. */
+    const fetched = apiGet("/api/catalog?server=" + encodeURIComponent(server)).then((r) => (r.kind === "data" && r.data ? r.data : null));
+    serverCatalogs.set(server, fetched);
+    fetched.then((catalog) => {
+      if (catalog === null) serverCatalogs.delete(server);
+      else setTimeout(() => serverCatalogs.delete(server), SERVER_CATALOG_TTL_MS);
+    }, () => serverCatalogs.delete(server));
   }
   return serverCatalogs.get(server);
 }
@@ -77,6 +91,7 @@ export function collectorIntervalFromCatalog(catalog, collector) {
  *   catalog's `view_max_hours[view]`, the number the server validates
  * @param {string} [opts.server] ask the catalog for this server's own collector interval
  * @param {boolean} [opts.useCatalogInterval] default true; false for a read that no collector feeds
+ * @param {boolean} [opts.offerReach] add the read's reach as the longest quick choice when it is longer than the shared 30 days (Alert History's 90)
  */
 export function pageRangePicker(opts) {
   const picker = timeRangePicker(opts);
@@ -85,6 +100,7 @@ export function pageRangePicker(opts) {
       const entry = await catalogEntryFor(opts.read);
       const viewMax = opts.view && entry && entry.params ? Number((hoursParam(entry).view_max_hours || {})[opts.view]) : NaN;
       picker.setReach(viewMax > 0 ? viewMax : opts.reachHours > 0 ? opts.reachHours : reachHours(entry));
+      if (opts.offerReach) offerReach(picker);
       if (opts.useCatalogInterval === false) return;
       if (opts.server) {
         const interval = collectorIntervalFromCatalog(await serverCatalog(opts.server), entry && entry.params ? hoursParam(entry).collector : null);
@@ -99,6 +115,12 @@ export function pageRangePicker(opts) {
   return { picker, ready };
 }
 
+/** The reach as the longest quick choice, when it is longer than the shared list's 30 days (#5562 review r1 M5, ruling R8). */
+function offerReach(picker) {
+  const hours = picker.reachHours();
+  if (hours * HOUR_MS > ROLLING_PRESETS[ROLLING_PRESETS.length - 1].spanMs) picker.setExtraPresets([relativeSpec(hours * HOUR_MS)]);
+}
+
 function hoursParam(entry) {
   return (entry.params || []).find((p) => p && p.name === "hours") || {};
 }
@@ -126,5 +148,6 @@ export function rollingHoursPicker(opts) {
       if (w) opts.onChange(w.hours);
     },
   });
+  offerReach(picker);
   return picker;
 }
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
index 686d65321c..638fa4e8e9 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
@@ -27,7 +27,7 @@ import { el, mount, readTool, apiSend, buildQuery, loadingStrip, errorStrip, emp
          ALERT_STATE_LABELS, alertDeliveryState } from "../util.js";
 import { VIZ, reapplyGridSort, gridRowOf } from "../panels.js";
 import { copyText } from "../grid-tools.js";
-import { pageRangePicker, windowOfSpec } from "../page-range.js";
+import { pageRangePicker, windowResultOfSpec } from "../page-range.js";
 import { relativeSpec, specName } from "../time-range.js";
 import { mutePrefillParams } from "../mute-context.js";
 import { orderServers } from "../server-order.js";
@@ -419,19 +419,35 @@ const DEFAULT_HOURS = 24;
 const LIMIT_CHOICES = [200, 500, 1000];
 const choices = { spec: relativeSpec(DEFAULT_HOURS * 3600000), limit: 200, server: "", dismissed: false };
 
-/* The get_alert_history parameters the current choices ask for. server_name and include_dismissed are left out
- * (buildQuery drops empty values) when they are at their defaults, and as_of when the range ends now. */
-function readParams() {
-  const w = windowOfSpec(choices.spec);
+/* The get_alert_history request the current choices ask for: `{ params, startMs }`, or `{ error }` when the range cannot be read right now
+ * (Today in its first five minutes) - the page shows that reason, never a different window (#5562 review r1 L3). server_name and
+ * include_dismissed are left out (buildQuery drops empty values) when they are at their defaults, and as_of when the range ends now.
+ * The read takes whole hours, so `startMs` is the range's exact start: the page trims the reply to it (review r1 H2). */
+function readRequest() {
+  const r = windowResultOfSpec(choices.spec);
+  if (r.error) return { error: r.error };
+  const w = r.window;
   return {
-    hours_back: w ? w.hours : DEFAULT_HOURS,
-    as_of: w ? w.asOf : null,
-    limit: choices.limit,
-    server_name: choices.server || null,
-    include_dismissed: choices.dismissed ? "true" : null,
+    startMs: w.startMs,
+    params: {
+      hours_back: w.hours,
+      as_of: w.asOf,
+      limit: choices.limit,
+      server_name: choices.server || null,
+      include_dismissed: choices.dismissed ? "true" : null,
+    },
   };
 }
 
+/* Keeps the alerts at or after the range start. The newest-first reply and the row cap mean the cut cannot hide an in-range row (the
+ * rows it drops are the oldest), the same argument job-history.js makes for its runs. An unreadable time is kept. */
+export function trimAlertsToStart(alerts, startMs) {
+  return alerts.filter((a) => {
+    const t = Date.parse(a && a.alert_time);
+    return Number.isNaN(t) || t >= startMs;
+  });
+}
+
 function windowLabel() {
   return specName(choices.spec).toLowerCase();
 }
@@ -595,6 +611,8 @@ export async function renderAlerts(main) {
     label: "Time range",
     /* No collector feeds the alert log, so there is no "collected every N minutes" note. */
     useCatalogInterval: false,
+    /* The longest choice is the alert table's retention (90 days, ruling R8), not only a typed "90d". */
+    offerReach: true,
     onChange: (spec) => { choices.spec = spec; changed(); },
   }).picker;
   const limitSel = picker("Row limit", LIMIT_CHOICES.map((n) => ({ value: n, label: n + " rows" })), choices.limit);
@@ -641,7 +659,8 @@ export async function renderAlerts(main) {
  * in order. A reply that arrives after a newer request was made is dropped. */
 async function refreshAlerts(state) {
   const seq = ++state.seq;
-  const res = await readTool("get_alert_history", readParams());
+  const req = readRequest();
+  const res = req.error ? { kind: "error", message: "This range cannot be read yet: " + req.error } : await readTool("get_alert_history", req.params);
   if (seq !== state.seq) return;
   state.meta.textContent = (choices.server ? choices.server : "fleet-wide") + " · " + windowLabel();
   mount(state.noticeBox, []);
@@ -655,7 +674,7 @@ async function refreshAlerts(state) {
     mount(state.tableBox, res.kind === "error" ? errorStrip(res.message) : emptyStrip(res.message));
     return;
   }
-  state.alerts = res.data.alerts || [];
+  state.alerts = trimAlertsToStart(res.data.alerts || [], req.startMs);
   state.truncated = res.data.truncated === true;
   /* A checked row that is no longer listed (dismissed elsewhere, aged out) is no longer selected. */
   const listed = new Set(state.alerts.filter(dismissable).map(alertKey));
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
index 3435ed4fc7..8e90d8d9c6 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
@@ -195,7 +195,9 @@ export const tab = {
       return finopsWindowControl({
         hours: state.days * 24,
         view: "storage_growth",
-        minSpanMs: DAY_MS,
+        /* The server reads hours_back = 24 as its 30-day default and refuses 2 to 6 days (DarlingMcpFinOpsTools.StorageGrowthWindowDaysFor), so the
+           shortest length the picker offers is a week (#5562 review r1 H1). */
+        minSpanMs: 7 * DAY_MS,
         stepMs: DAY_MS,
         onChange: (hours) => {
           state.days = hours / 24;
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js
index 237b07a7cc..af3a591878 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/job-history.js
@@ -132,11 +132,15 @@ export function trimRunsToStart(data, w) {
   };
 }
 
+/** The window the held range reads as of now, or the default one when it cannot resolve. */
+function currentWindow() {
+  return windowOfSpec(state.spec) || windowOfSpec(relativeSpec(DEFAULT_HOURS * 3600000));
+}
+
 /** The read's parameters for the current filters; an empty filter is left off so the read applies none. */
-export function readParams() {
+export function readParams(w = currentWindow()) {
   /* A finished range sends its end as `as_of` (#5562 R6). The reader bounds the runs by that end in SQL, before the row limit
      (JobHistoryFilter.UntilUtc, DarlingJobHistoryReader.cs), so the newest runs the limit keeps are the range's own. */
-  const w = windowOfSpec(state.spec) || windowOfSpec(relativeSpec(DEFAULT_HOURS * 3600000));
   const p = { hours: w.hours, limit: state.limit };
   if (w.asOf) p.as_of = w.asOf;
   if (state.server) p.server = state.server;
@@ -298,14 +302,17 @@ export function renderJobHistory(main) {
     const signal = (loadAbort = new AbortController()).signal;
     mount(body, loadingStrip("Loading job history…"));
     try {
-      const res = await readToolWithinKeptHistory("get_job_history", readParams(), signal);
+      /* One window for the request and the trim: a live range's start moves with the clock, so a window recomputed after the reply would cut
+         later than the read began (#5562 review r1 L7). */
+      const w = currentWindow();
+      const res = await readToolWithinKeptHistory("get_job_history", readParams(w), signal);
       if (ticket !== loadSeq) return;
       if (res.kind === "aborted" || res.kind === "auth") return;
       if (res.kind === "error") {
         showAgent(null);
         return mount(body, readErrorStrip(res.message));
       }
-      const data = trimRunsToStart(res.data || {}, windowOfSpec(state.spec));
+      const data = trimRunsToStart(res.data || {}, w);
       const kept = keptWindowStrip(res);
       showAgent(res.kind === "empty" ? res.hints : data);
       if (res.kind === "empty") {
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
index 584dd30986..444cb30016 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
@@ -146,7 +146,7 @@ function holdSpec(server, spec, nowMs) {
     customRanges.delete(server);
     pageHours = hours;
   } else {
-    customRanges.set(server, { spec, live: resolved.range.live });
+    customRanges.set(server, { spec, live: resolved.range.live || resolved.range.endMs >= nowMs });
   }
   return null;
 }
@@ -182,10 +182,16 @@ export function rangeContext(nowMs = Date.now()) {
       const named = custom.spec.kind === "relative" || custom.spec.kind === "calendar" ? specName(custom.spec).toLowerCase() : "custom";
       return { hours: w.hours, label: named + ": " + times + rounded, custom: true };
     }
-    customRanges.delete(current.server);
+    if (resolved.ok) customRanges.delete(current.server);
   }
   setActiveRange(null);
   const opt = RANGE_OPTIONS.find((o) => o.hours === pageHours) || RANGE_OPTIONS.find((o) => o.hours === 24) || RANGE_OPTIONS[0];
+  /* A held range that cannot resolve right now (Today in its first five minutes) is kept, not dropped: the label says so and names the
+     window shown instead, and the range reads again once it can (#5562 review r1 L3). */
+  if (custom) {
+    const unresolved = resolveSpec(custom.spec, nowMs, browserZone());
+    if (!unresolved.ok) return { hours: opt.hours, label: specName(custom.spec).toLowerCase() + " cannot be read yet (" + unresolved.error.message + "); showing " + opt.label };
+  }
   return { hours: opt.hours, label: opt.label };
 }
 
@@ -397,6 +403,9 @@ function applySampleNote() {
   serverCatalog(server).then((catalog) => {
     if (picker !== rangePicker || tab !== current.tab || server !== current.server) return;
     picker.setSampleInterval(collectorIntervalFromCatalog(catalog, tab.collector));
+  }).catch(() => {
+    /* A catalog that cannot be read shows no note (#5562 review r1 L2); the next tab or range change asks again. */
+    if (picker === rangePicker) picker.setSampleInterval(null);
   });
 }
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
index c7f0c128f8..05f76daf39 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
@@ -40,7 +40,6 @@ import {
   minSpanRefusal,
   reachText,
   sampleIntervalNote,
-  dataStartNote,
   wallText,
 } from "./time-range.js";
 
@@ -56,7 +55,7 @@ let pickerCount = 0;
  * @param {() => number} [opts.now] the clock, epoch ms (default Date.now); tests give their own
  * @param {number} [opts.reachHours] the longest range the page's reads take, in hours (default 168); longer ones are greyed out
  * @param {number|null} [opts.sampleIntervalMs] the main collector's interval; a span with fewer than 3 samples shows a note
- * @param {number|null} [opts.dataStartMs] where the data begins; a range starting well before it shows a note
+ * @param {object[]} [opts.extraPresets] quick choices added after the shared list (a read that reaches past 30 days offers its reach)
  * @param {boolean} [opts.compact] hide the detail beside the button (it moves into the tooltip)
  * @param {boolean} [opts.rollingOnly] offer only "this long back from now" (#5562 R5, the FinOps pages): no calendar periods, no
  *   custom end, whole hours, at least one hour. A range outside that is greyed out or refused with the reason, never clamped.
@@ -71,9 +70,11 @@ export function timeRangePicker(opts = {}) {
   const name = opts.label || "Time range";
   const previewId = "trp-preview-" + ++pickerCount;
   let spec = opts.spec || relativeSpec(DAY_MS);
+  /* Longer quick choices a page adds when its read reaches past the 30 days the shared list stops at (#5562 review r1 M5): the longest
+     choice a page offers is its reach. */
+  let extraPresets = Array.isArray(opts.extraPresets) ? opts.extraPresets : [];
   let reach = opts.reachHours > 0 ? opts.reachHours : DEFAULT_REACH_HOURS;
   let sampleIntervalMs = opts.sampleIntervalMs || null;
-  let dataStartMs = opts.dataStartMs ?? null;
   const onChange = opts.onChange || (() => {});
   let open = false;
   let popup = null;
@@ -83,6 +84,8 @@ export function timeRangePicker(opts = {}) {
   let pending = null;
   let fromBox = null;
   let toBox = null;
+  /* The end box's prefilled value while the held range is live; an end left at it still means "now" (#5562 review r1 M3). */
+  let prefilledLiveEnd = null;
   let removeDocumentListeners = null;
 
   const button = el("button", { type: "button", class: "trp-button", "aria-haspopup": "dialog", "aria-expanded": "false" });
@@ -113,7 +116,7 @@ export function timeRangePicker(opts = {}) {
     button.setAttribute("aria-label", name + ": " + text + ", " + where);
     detail.textContent = opts.compact ? "" : where;
     node.setAttribute("title", opts.compact ? text + ", " + where : "");
-    const notes = [sampleIntervalNote(range.spanMs, sampleIntervalMs), dataStartNote(range, dataStartMs)].filter(Boolean);
+    const notes = [sampleIntervalNote(range.spanMs, sampleIntervalMs)].filter(Boolean);
     note.textContent = notes.join(" ");
   }
 
@@ -184,7 +187,7 @@ export function timeRangePicker(opts = {}) {
       return;
     }
     pending = r;
-    const notes = [sampleIntervalNote(r.range.spanMs, sampleIntervalMs), dataStartNote(r.range, dataStartMs)].filter(Boolean);
+    const notes = [sampleIntervalNote(r.range.spanMs, sampleIntervalMs)].filter(Boolean);
     preview.textContent = [r.echo, ...notes].join(" ");
     preview.className = "trp-preview trp-ok";
     applyButton.disabled = false;
@@ -201,7 +204,10 @@ export function timeRangePicker(opts = {}) {
   /* The date and time boxes write the typed form (in the picker's zone), so one path parses, previews and applies. */
   function pickChanged() {
     if (!fromBox.value || !toBox.value) return;
-    textBox.value = fromBox.value.replace("T", " ") + " - " + toBox.value.replace("T", " ");
+    /* A live range stays live when only the start moves: the end box still holding the value the popup filled in is "now", not a typed end,
+       so the text reads "<start> - now" (a since-range, kept refreshing by the page's poll) instead of freezing at the popup-open minute. */
+    const endText = prefilledLiveEnd !== null && toBox.value === prefilledLiveEnd ? "now" : toBox.value.replace("T", " ");
+    textBox.value = fromBox.value.replace("T", " ") + " - " + endText;
     showPreview();
   }
 
@@ -216,6 +222,7 @@ export function timeRangePicker(opts = {}) {
     if (r.ok) {
       fromBox.value = wallText(r.range.startMs, zone).replace(" ", "T").slice(0, 16);
       toBox.value = wallText(r.range.endMs, zone).replace(" ", "T").slice(0, 16);
+      prefilledLiveEnd = r.range.live ? toBox.value : null;
     }
     textBox.addEventListener("input", showPreview);
     textBox.addEventListener("keydown", (e) => {
@@ -230,7 +237,7 @@ export function timeRangePicker(opts = {}) {
 
     const quick = el("div", { class: "trp-column" }, [
       el("div", { class: "trp-heading", text: "Quick ranges" }),
-      ...ROLLING_PRESETS.map((s) => item(s, nowMs)),
+      ...ROLLING_PRESETS.concat(extraPresets.filter((x) => !ROLLING_PRESETS.some((p) => specId(p) === specId(x)))).map((s) => item(s, nowMs)),
     ]);
     const periods = el("div", { class: "trp-column" }, [
       el("div", { class: "trp-heading", text: "Calendar periods" }),
@@ -304,7 +311,7 @@ export function timeRangePicker(opts = {}) {
     /** The window the reads take for the range now ({ hours, asOf, live, startMs, endMs }), or null. */
     window() {
       const r = current();
-      return r.ok ? readWindow(r.range) : null;
+      return r.ok ? readWindow(r.range, now()) : null;
     },
     spec() {
       return spec;
@@ -331,10 +338,16 @@ export function timeRangePicker(opts = {}) {
       sampleIntervalMs = ms || null;
       draw();
     },
-    setDataStart(ms) {
-      dataStartMs = ms ?? null;
-      draw();
+    /** Add quick choices longer than the shared list (the page's own reach); a popup that is open redraws. */
+    setExtraPresets(specs) {
+      extraPresets = Array.isArray(specs) ? specs : [];
+      if (open) {
+        close(false);
+        openPopup();
+      }
     },
+    /** The longest range the page takes, in hours. */
+    reachHours: () => reach,
     openPopup,
     close: () => close(true),
     isOpen: () => open,
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
index 95b35b4def..32b364e70c 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
@@ -896,12 +896,17 @@ export function minSpanRefusal(spanMs, minSpanMs) {
  * number of hours (at least 1), so the fetch starts at or before the range start and the page trims to the exact pair; `asOf` is
  * the end as ISO text, or null for a live range, whose reads are anchored at the server's own clock.
  */
-export function readWindow(range) {
+export function readWindow(range, nowMs = Date.now()) {
+  /* A fixed range whose end is at or after now is a live range ending now (#5562 review r1 M2): it is sent with no as_of, which a
+     read would refuse as "in the future", and it keeps refreshing until the clock passes the end. */
+  const endsNow = range.live || range.endMs >= nowMs;
+  const endMs = endsNow ? Math.max(range.startMs, Math.min(range.endMs, nowMs)) : range.endMs;
+  const spanMs = endsNow && !range.live ? Math.max(0, endMs - range.startMs) : range.spanMs;
   return {
-    hours: Math.max(1, Math.ceil(range.spanMs / HOUR_MS)),
-    asOf: range.live ? null : new Date(range.endMs).toISOString(),
-    live: range.live,
+    hours: Math.max(1, Math.ceil(spanMs / HOUR_MS)),
+    asOf: endsNow ? null : new Date(range.endMs).toISOString(),
+    live: endsNow,
     startMs: range.startMs,
-    endMs: range.endMs,
+    endMs: endsNow && !range.live ? endMs : range.endMs,
   };
 }
diff --git a/PerformanceMonitor.Common/Mcp/McpHelpers.cs b/PerformanceMonitor.Common/Mcp/McpHelpers.cs
index d0eb3d29b5..ae33cae2a1 100644
--- a/PerformanceMonitor.Common/Mcp/McpHelpers.cs
+++ b/PerformanceMonitor.Common/Mcp/McpHelpers.cs
@@ -235,8 +235,8 @@ private static string DescribeCeiling(int maxHours) =>
 
     /// <summary>
     /// <see cref="ValidateWindow(int, string, out DateTime)"/> with the read's own ceiling (#5562): the opt-in a
-    /// bucketed trend read uses to accept a window past <see cref="MaxHoursBack"/>. Lists and rankings do not call
-    /// this; they stay on the 168-hour overload. Refuses, never clamps.
+    /// bucketed trend read uses to accept a window past <see cref="MaxHoursBack"/>. Lists and rankings stay on the
+    /// 168-hour overload, except <c>get_alert_history</c> (a list, ruling R8), which passes its retention. Refuses, never clamps.
     /// </summary>
     public static string? ValidateWindow(int hoursBack, string? asOf, int maxHours, out DateTime endUtc)
     {

From 9a127c23d4bdc7571e9770a3a1d6a73ca2717bd6 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 13:14:37 -0400
Subject: [PATCH 23/33] Web picker review round 1: perfmon and heatmap keep the
 168 hour overload, harness clocks follow the range trim (#5562)

---
 Darling/Darling.Tests/AlertHistoryRangePageTests.cs       | 8 +++++---
 Darling/Darling.Tests/WebReadReachLiveTests.cs            | 2 +-
 Darling/Darling.Tests/alert-history-advice-harness.mjs    | 4 +++-
 Darling/Darling.Tests/alert-history-dismiss-harness.mjs   | 6 ++++--
 .../Mcp/DarlingMcpTrendTools.cs                           | 4 ++--
 5 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
index 5a2b95169c..17c9ecfb76 100644
--- a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
+++ b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
@@ -34,9 +34,11 @@ public void ThePageReadsGetAlertHistoryWithTheFourChoicesAndNeverAFixedWindow()
         Assert.DoesNotContain("limit: 200 }", page);
         Assert.Contains("readTool(\"get_alert_history\", req.params)", page);
         // #5562: the range is the shared picker's spec, read as of each read; a finished range also sends its end.
-        Assert.Contains("const w = windowOfSpec(choices.spec);", page);
-        Assert.Contains("hours_back: w ? w.hours : DEFAULT_HOURS", page);
-        Assert.Contains("as_of: w ? w.asOf : null", page);
+        Assert.Contains("windowResultOfSpec(choices.spec);", page);
+        Assert.Contains("hours_back: w.hours", page);
+        Assert.Contains("as_of: w.asOf", page);
+        // Review r1 H2: the reply is trimmed to the range start, since the read takes whole hours.
+        Assert.Contains("trimAlertsToStart(res.data.alerts || [], req.startMs)", page);
         Assert.Contains("limit: choices.limit", page);
         Assert.Contains("server_name: choices.server || null", page);
         Assert.Contains("include_dismissed: choices.dismissed ? \"true\" : null", page);
diff --git a/Darling/Darling.Tests/WebReadReachLiveTests.cs b/Darling/Darling.Tests/WebReadReachLiveTests.cs
index 9d046a0ba8..479e76844c 100644
--- a/Darling/Darling.Tests/WebReadReachLiveTests.cs
+++ b/Darling/Darling.Tests/WebReadReachLiveTests.cs
@@ -153,7 +153,7 @@ await DarlingMcpTestData.ExecAsync(connection, ct,
             }
 
             /* Raised-then-lowered (#5562 review r1): the perfmon trend (11.2 s cold at 30 days, #5574) and the heatmap (raw query_stats, four days on a TimescaleDB store) stay at 168. */
-            foreach (var read in new[] { "get_perfmon_trend", "get_query_heatmap" })
+            foreach (var read in new[] { "get_query_heatmap" })
             {
                 Assert.Contains("exceeds maximum of 168 hours (7 days)",
                     McpHelpers.ErrorMessageOf(await WebReadAsync(postgres, read, McpHelpers.MaxHoursBack + 1)));
diff --git a/Darling/Darling.Tests/alert-history-advice-harness.mjs b/Darling/Darling.Tests/alert-history-advice-harness.mjs
index dd41b5ae10..f9e8d7a321 100644
--- a/Darling/Darling.Tests/alert-history-advice-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-advice-harness.mjs
@@ -81,7 +81,9 @@ globalThis.fetch = async (url, init) => {
 const detailReadsOf = () => urls.filter((u) => u.includes("/get_alert_details")).map((u) => Object.fromEntries(new URL(u, "http://x").searchParams));
 const readsOf = () => urls.filter((u) => u.includes("/get_alert_history")).map((u) => Object.fromEntries(new URL(u, "http://x").searchParams));
 
-const T0 = Date.now();
+// The page trims a reply to the range start (review r1 H2), so the clock sits just after the fixed alert times.
+const T0 = Date.UTC(2026, 0, 1, 12, 0, 0) + 60000;
+Date.now = () => T0 + 30000;
 const row = (i, over = {}) => ({
   alert_time: new Date(T0 - 60000 - i * 60000).toISOString(),
   server_id: 1, server_name: "srv-a", stored_server_name: "srv-a", metric_name: "High CPU " + i,
diff --git a/Darling/Darling.Tests/alert-history-dismiss-harness.mjs b/Darling/Darling.Tests/alert-history-dismiss-harness.mjs
index 27710e04dd..e1c3b110bb 100644
--- a/Darling/Darling.Tests/alert-history-dismiss-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-dismiss-harness.mjs
@@ -75,7 +75,9 @@ globalThis.fetch = async (url, init) => {
 };
 const readsOf = () => urls.filter((u) => u.includes("/get_alert_history")).map((u) => Object.fromEntries(new URL(u, "http://x").searchParams));
 
-const T0 = Date.now();
+// The page trims a reply to the range start (review r1 H2), so the clock sits just after the fixed alert times.
+const T0 = Date.UTC(2026, 0, 1, 12, 0, 0) + 60000;
+Date.now = () => T0 + 30000;
 const row = (i, over = {}) => ({
   alert_time: new Date(T0 - 60000 - i * 60000).toISOString(),
   server_id: 1, server_name: "srv-a", stored_server_name: "srv-a", metric_name: "High CPU " + i,
@@ -159,7 +161,7 @@ try {
       out.all = posts.map((p) => ({ url: p.url, contentType: p.contentType, keys: p.req.alerts }));
     },
     async chunks() {
-      const many = Array.from({ length: 1500 }, (_, i) => row(i + 1));
+      const many = Array.from({ length: 1500 }, (_, i) => row(i + 1, { alert_time: new Date(T0 - 60000 - i * 30000).toISOString() })); // 30 s apart so all 1500 sit inside the default day
       alertsReply = { alerts: many, truncated: false };
       const main = newMain(); await renderAlerts(main);
       alertsReply = { alerts: [], truncated: false };
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
index dba5f24dbc..5fdf6dced7 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
@@ -189,8 +189,8 @@ internal static async Task<string> GetPerfmonTrend(
 
         /* #5562: stays at 168 h. The re-time on a large store read 11.2 s cold at 30 days even with the LIKE predicate (DarlingTrendReader.PerfmonTrendSql,
            which saved 1.3 s cold): the compressed perfmon_stats data is grouped by server only, so the read decodes every counter's name no matter which
-           counter was asked for. A month is too slow to offer (#5574 tracks compressing the data by counter so it can reach 30 days); the ceiling is the WebReadReach row. */
-        var validation = McpHelpers.ValidateWindow(hours_back, as_of, WebReadReach.MaxHoursFor("get_perfmon_trend"), out var windowEnd);
+           counter was asked for. A month is too slow to offer (#5574 tracks compressing the data by counter so it can reach 30 days); this keeps the 168-hour overload, as its WebReadReach row says. */
+        var validation = McpHelpers.ValidateWindow(hours_back, as_of, out var windowEnd);
         if (validation != null) return validation;
 
         var bucketError = TrendBuckets.Resolve(hours_back, bucket_minutes, 1, budget, out var bucketMinutes);

From 51240a29da19312ee6dd7998d9912e7a9af28c5f Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 13:22:12 -0400
Subject: [PATCH 24/33] A calendar period is exempt from the 5 minute floor in
 the web module; it is refused only at zero length (#5562)

---
 .../wwwroot/js/page-range.js                          |  4 ++--
 .../wwwroot/js/pages/alerts.js                        |  2 +-
 .../wwwroot/js/time-range-picker.js                   |  2 +-
 .../wwwroot/js/time-range.js                          | 11 +++++++----
 4 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
index c1663925fd..37a4dac099 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
@@ -31,7 +31,7 @@ const SERVER_CATALOG_TTL_MS = 5 * 60000;
 const serverCatalogs = new Map();
 
 /** The window a read takes for a held spec as of now: `{ hours, asOf, live, startMs, endMs }`, or null when the spec cannot be resolved
- *  (a calendar period under five minutes old). A page that keeps its choice at module scope (so a 60 s poll or a visit elsewhere keeps
+ *  (a calendar period at exactly its start, zero length). A page that keeps its choice at module scope (so a 60 s poll or a visit elsewhere keeps
  *  it) calls this on every read, so a live range slides with the clock. */
 export function windowOfSpec(spec, nowMs = Date.now(), zone = browserZone()) {
   const r = resolveSpec(spec, nowMs, zone);
@@ -39,7 +39,7 @@ export function windowOfSpec(spec, nowMs = Date.now(), zone = browserZone()) {
 }
 
 /** Like windowOfSpec, but says why a spec cannot be read: `{ window }` or `{ error: message }`. A page shows the message (a Today range
- *  in its first five minutes) instead of quietly reading a different window (#5562 review r1 L3). */
+ *  at exactly midnight) instead of quietly reading a different window (#5562 review r1 L3). */
 export function windowResultOfSpec(spec, nowMs = Date.now(), zone = browserZone()) {
   const r = resolveSpec(spec, nowMs, zone);
   return r.ok ? { window: readWindow(r.range, nowMs) } : { error: r.error.message };
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
index 638fa4e8e9..44a21b2dba 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
@@ -420,7 +420,7 @@ const LIMIT_CHOICES = [200, 500, 1000];
 const choices = { spec: relativeSpec(DEFAULT_HOURS * 3600000), limit: 200, server: "", dismissed: false };
 
 /* The get_alert_history request the current choices ask for: `{ params, startMs }`, or `{ error }` when the range cannot be read right now
- * (Today in its first five minutes) - the page shows that reason, never a different window (#5562 review r1 L3). server_name and
+ * (Today at exactly midnight, zero length) - the page shows that reason, never a different window (#5562 review r1 L3). server_name and
  * include_dismissed are left out (buildQuery drops empty values) when they are at their defaults, and as_of when the range ends now.
  * The read takes whole hours, so `startMs` is the range's exact start: the page trims the reply to it (review r1 H2). */
 function readRequest() {
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
index 05f76daf39..f9ca096339 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
@@ -94,7 +94,7 @@ export function timeRangePicker(opts = {}) {
   const popupSlot = el("div", { class: "trp-popup-slot" });
   const node = el("div", { class: "time-range-picker" + (opts.compact ? " trp-compact" : "") }, [button, detail, note, popupSlot]);
 
-  /* The range as it resolves right now, or the error that stops it (a calendar period under 5 minutes old, say). */
+  /* The range as it resolves right now, or the error that stops it (a calendar period at exactly its start, say). */
   function current() {
     return resolveSpec(spec, now(), zone);
   }
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
index 32b364e70c..c7cef9f860 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
@@ -20,7 +20,7 @@
  * wall-clock midnights, weeks start Monday, and a boundary is the earliest instant labelled at or after the wall midnight
  * so neighbouring periods tile; typed wall times take the widest instants they can mean (a start the earliest, an end the
  * latest; a repeated hour widens, a skipped time maps to the change instant); nothing shorter than 5 minutes is accepted
- * and nothing is widened; there is no upper cap here (a page decides what its reads reach).
+ * (a calendar period is exempt, once it has started) and nothing is widened; there is no upper cap here (a page decides what its reads reach).
  *
  * A spec is a plain object: { kind: "relative", spanMs }, { kind: "calendar", period }, { kind: "fixed", startMs, endMs } or
  * { kind: "since", startMs }. resolveSpec turns it into a range for a now and a zone; parseRange turns text into one.
@@ -401,7 +401,7 @@ function buildRange(spec, startMs, endMs, live, zone, nowMs) {
 
 /**
  * The instants a spec means at `nowMs` in `zone`: `{ ok: true, range }` or `{ ok: false, error: { code, message } }` (shorter than
- * 5 minutes, ends before it starts, reaches back too far). The range carries startMs, endMs, live (the end slides with now),
+ * 5 minutes unless it is a calendar period, ends before it starts, reaches back too far). The range carries startMs, endMs, live (the end slides with now),
  * spanMs, length, startText, endText, zoneText and label ("3d  Oct 5, 12:00 am - Oct 8, 7:01 am (UTC-04:00)").
  */
 export function resolveSpec(spec, nowMs, zone) {
@@ -436,11 +436,14 @@ export function resolveSpec(spec, nowMs, zone) {
       ? fail("start_in_future", "That start has not happened yet.")
       : fail("end_before_start", "The end is before the start.");
   }
-  if (end - start < MINIMUM_SPAN_MS) return fail("too_short", shortMessage(end - start));
+  /* A calendar period is exempt from the 5-minute floor (#5562): "Today" at 00:02 reads 00:00 to now and the "collected every N min" note
+     explains a sparse chart; no other range is ever substituted. Typed spans, "since" and custom start/end keep the floor. A period that
+     has not started (zero length, exactly midnight) is still refused. */
+  if (spec.kind === "calendar" ? end <= start : end - start < MINIMUM_SPAN_MS) return fail("too_short", shortMessage(end - start));
   return { ok: true, range: buildRange(spec, start, end, live, zone, nowMs) };
 }
 
-/** The current length of a spec ("7h 1m" for Today), or null when it cannot be used right now (a calendar period under 5 minutes). */
+/** The current length of a spec ("7h 1m" for Today, "2m" just after midnight), or null when it cannot be used right now (a calendar period at exactly its start, zero length). */
 export function currentLength(spec, nowMs, zone) {
   const r = resolveSpec(spec, nowMs, zone);
   return r.ok ? r.range.length : null;

From 650b0bee95c33ff7a41af8ce7b8cf8d520c4f400 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 13:41:30 -0400
Subject: [PATCH 25/33] The server catalog cache expires on lookup, not on a 5
 minute timer that held Node open for 300 s per harness run; pin Today's floor
 exemption and the cache lifetime (#5562)

---
 Darling/Darling.Tests/WebPageRangeTests.cs    | 13 ++++++++
 Darling/Darling.Tests/page-range-harness.mjs  | 32 +++++++++++++++++++
 .../wwwroot/js/page-range.js                  | 24 ++++++++++----
 3 files changed, 62 insertions(+), 7 deletions(-)

diff --git a/Darling/Darling.Tests/WebPageRangeTests.cs b/Darling/Darling.Tests/WebPageRangeTests.cs
index bfb76ae95d..a80dd0b82d 100644
--- a/Darling/Darling.Tests/WebPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebPageRangeTests.cs
@@ -201,6 +201,19 @@ public void ThePureParts_RunUnderNode()
         Assert.Equal(24, window.GetProperty("finished").GetProperty("hours").GetInt32());
         Assert.Equal("2026-10-08T10:00:00.000Z", window.GetProperty("finished").GetProperty("asOf").GetString());
 
+        // R9: Today two minutes after midnight is held (a calendar period is exempt from the floor); exactly midnight is refused; a typed span keeps the floor.
+        var floor = r.GetProperty("calendarFloor");
+        Assert.Equal(1, floor.GetProperty("twoMinutesIn").GetProperty("window").GetProperty("hours").GetInt32());
+        Assert.Contains("shortest range is 5 minutes", floor.GetProperty("atMidnight").GetProperty("error").GetString());
+        Assert.Equal("too_short", floor.GetProperty("typedUnderFloor").GetString());
+
+        // The per-server catalog is read once, kept for its time to live, then read again (and expires on lookup, not on a timer that holds Node open).
+        var ttl = r.GetProperty("catalogTtl");
+        Assert.Equal(1, ttl.GetProperty("afterTwoLookups").GetInt32());
+        Assert.Equal(1, ttl.GetProperty("afterFourMinutes").GetInt32());
+        Assert.Equal(2, ttl.GetProperty("afterSixMinutes").GetInt32());
+        Assert.DoesNotContain("setTimeout(() => serverCatalogs", Js("page-range.js"));
+
         // The sweep timeline and the job runs are cut at the range's start (newest first, so a row cap cannot hide a run in range).
         Assert.Equal(3, r.GetProperty("sweeps").GetProperty("kept").GetInt32());
         Assert.Equal(2, r.GetProperty("sweeps").GetProperty("all").GetInt32());
diff --git a/Darling/Darling.Tests/page-range-harness.mjs b/Darling/Darling.Tests/page-range-harness.mjs
index 31d102a099..60837d54b1 100644
--- a/Darling/Darling.Tests/page-range-harness.mjs
+++ b/Darling/Darling.Tests/page-range-harness.mjs
@@ -71,6 +71,38 @@ try {
     finished: w(tr.fixedSpec(now - 26 * HOUR, now - 2 * HOUR)),
   };
 
+  /* R9: a calendar period is exempt from the 5 minute floor and refused only at zero length (exactly midnight). */
+  const today = (iso) => pageRange.windowResultOfSpec(tr.calendarSpec("today"), Date.parse(iso), "UTC");
+  out.calendarFloor = {
+    twoMinutesIn: today("2026-10-08T00:02:00Z"),
+    atMidnight: today("2026-10-08T00:00:00Z"),
+    typedUnderFloor: tr.resolveSpec(tr.relativeSpec(3 * MIN), now, "UTC").error.code,
+  };
+
+  /* A server's catalog is read once, kept until its time is up and then read again. The entry expires on lookup, not on a timer:
+     a pending timer would keep this process (and a test waiting on it) alive for the whole time to live. */
+  let catalogReads = 0;
+  let clock = now;
+  const realNow = Date.now;
+  Date.now = () => clock;
+  globalThis.fetch = async () => {
+    catalogReads++;
+    return { ok: true, status: 200, text: async () => JSON.stringify(catalog(1)) };
+  };
+  try {
+    await pageRange.serverCatalog("SRV1");
+    await pageRange.serverCatalog("SRV1");
+    const afterTwoLookups = catalogReads;
+    clock += 4 * MIN;
+    await pageRange.serverCatalog("SRV1");
+    const afterFourMinutes = catalogReads;
+    clock += 2 * MIN;
+    await pageRange.serverCatalog("SRV1");
+    out.catalogTtl = { afterTwoLookups, afterFourMinutes, afterSixMinutes: catalogReads };
+  } finally {
+    Date.now = realNow;
+  }
+
   const sweeps = await load("pages", "sweeps.js");
   const stamp = (minutesAgo) => ({ swept_at: new Date(now - minutesAgo * MIN).toISOString() });
   const trimmed = sweeps.timelineSweeps([stamp(5), stamp(20), stamp(50), { swept_at: "not a time" }], pageRange.windowOfSpec(tr.relativeSpec(30 * MIN), now, "UTC"));
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
index 37a4dac099..9543e101de 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
@@ -53,17 +53,27 @@ export async function catalogEntryFor(read) {
 
 /** The catalog with the SERVER's own collector intervals (a per-server schedule row wins), cached per server. Null when it cannot be read. */
 export function serverCatalog(server) {
+  const held = serverCatalogs.get(server);
+  /* An entry expires when it is looked up after its time, not by a timer: a pending timer keeps a Node harness alive for the whole
+     TTL (the picker harness waited 300 s to exit before this). */
+  if (held && held.readAt !== null && Date.now() - held.readAt >= SERVER_CATALOG_TTL_MS) serverCatalogs.delete(server);
   if (!serverCatalogs.has(server)) {
     /* Only a catalog that was read is kept (#5562 review r1 L2): a failed fetch is not cached as null for the page's life, and a
        schedule edited in Settings is seen again after the entry expires. */
-    const fetched = apiGet("/api/catalog?server=" + encodeURIComponent(server)).then((r) => (r.kind === "data" && r.data ? r.data : null));
-    serverCatalogs.set(server, fetched);
-    fetched.then((catalog) => {
-      if (catalog === null) serverCatalogs.delete(server);
-      else setTimeout(() => serverCatalogs.delete(server), SERVER_CATALOG_TTL_MS);
-    }, () => serverCatalogs.delete(server));
+    const entry = { readAt: null, fetched: null };
+    entry.fetched = apiGet("/api/catalog?server=" + encodeURIComponent(server)).then((r) => (r.kind === "data" && r.data ? r.data : null));
+    serverCatalogs.set(server, entry);
+    entry.fetched.then((catalog) => {
+      if (catalog === null) {
+        if (serverCatalogs.get(server) === entry) serverCatalogs.delete(server);
+      } else {
+        entry.readAt = Date.now();
+      }
+    }, () => {
+      if (serverCatalogs.get(server) === entry) serverCatalogs.delete(server);
+    });
   }
-  return serverCatalogs.get(server);
+  return serverCatalogs.get(server).fetched;
 }
 
 /** The interval, in milliseconds, of one collector on this server as the catalog serves it: every read of a collector carries the same

From c0c2191b0a3316209d391da6fb7072468dd0cb34 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 13:49:58 -0400
Subject: [PATCH 26/33] Job History page pin follows the page's readParams(w)
 call (#5562)

---
 Darling/Darling.Tests/JobHistoryPageTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Darling/Darling.Tests/JobHistoryPageTests.cs b/Darling/Darling.Tests/JobHistoryPageTests.cs
index 458dda8aea..f0ac931d97 100644
--- a/Darling/Darling.Tests/JobHistoryPageTests.cs
+++ b/Darling/Darling.Tests/JobHistoryPageTests.cs
@@ -36,7 +36,7 @@ private static string Wwwroot(params string[] parts) =>
     public void ThePageReadsGetJobHistoryThroughTheSharedReadWithASignal()
     {
         var page = Page();
-        Assert.Contains("readToolWithinKeptHistory(\"get_job_history\", readParams(), signal)", page);
+        Assert.Contains("readToolWithinKeptHistory(\"get_job_history\", readParams(w), signal)", page);
         Assert.Contains("readTool(\"list_servers\", {}, controller.signal)", page);
         Assert.Contains("VIZ.table(data,", page);
         Assert.Contains("rowsKey: \"runs\"", page);

From 3b2d24665481c53718e92a2501e3ab1102272b7a Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 14:17:42 -0400
Subject: [PATCH 27/33] Server page: each tab reads its reach from the catalog,
 and a range longer than the tab reads is cut with a notice (#5562 review r1
 M4)

---
 Darling/Darling.Tests/ServerPageTabsTests.cs  |   2 +-
 .../Darling.Tests/WebServerPageRangeTests.cs  | 193 ++++++++++++++++--
 .../web-kept-history-harness.mjs              |  98 ++++++++-
 .../wwwroot/js/page-range.js                  |  14 +-
 .../wwwroot/js/pages/analysis-findings.js     |   2 +
 .../wwwroot/js/pages/server-tabs.js           |  70 +++++++
 .../wwwroot/js/pages/server.js                | 166 +++++++++++----
 .../wwwroot/js/time-range-picker.js           |   8 +-
 8 files changed, 491 insertions(+), 62 deletions(-)

diff --git a/Darling/Darling.Tests/ServerPageTabsTests.cs b/Darling/Darling.Tests/ServerPageTabsTests.cs
index 7158bf54ce..247b969622 100644
--- a/Darling/Darling.Tests/ServerPageTabsTests.cs
+++ b/Darling/Darling.Tests/ServerPageTabsTests.cs
@@ -898,7 +898,7 @@ public void TheTabsThatCannotDoWhatTheDesktopDoes_SaySo()
 
         /* The note renders — a `note` field with no renderer is the same silence in a different place. */
         Assert.Contains("return note ? noticeStrip(note) : null;", js, StringComparison.Ordinal);
-        Assert.Contains("tabNote(tab, WIDEST_RANGE_HOURS)", ServerJs, StringComparison.Ordinal);
+        Assert.Contains("tabNote(tab, tabReach())", ServerJs, StringComparison.Ordinal);
     }
 
     /// <summary>
diff --git a/Darling/Darling.Tests/WebServerPageRangeTests.cs b/Darling/Darling.Tests/WebServerPageRangeTests.cs
index 9cd1655a58..37584d7547 100644
--- a/Darling/Darling.Tests/WebServerPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebServerPageRangeTests.cs
@@ -11,6 +11,7 @@
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using PerformanceMonitor.Common;
+using PerformanceMonitor.Darling.Service;
 using Xunit;
 using static Darling.Tests.RepoFile;
 
@@ -34,7 +35,7 @@ public sealed class WebServerPageRangeTests
     [Fact]
     public void EveryOfferedRange_IsOneEveryRangedReadOnEveryTabTakes()
     {
-        if (!WebRangeKeptHistoryBehaviourTests.TryRun("offeredRanges:" + McpHelpers.MaxHoursBack, out var r)) return;
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("offeredRanges:" + McpHelpers.MaxHoursBack, out var r, CatalogJson())) return;
 
         var offered = r.GetProperty("offered").EnumerateArray().Select(e => e.GetInt32()).ToArray();
         Assert.NotEmpty(offered);
@@ -49,11 +50,11 @@ public void EveryOfferedRange_IsOneEveryRangedReadOnEveryTabTakes()
            timer, say) reaches the run's list of every fetch without reaching a tab's, and the last tab's has nothing
            after it to be counted in. So the whole list is checked as well: no read the page makes asks for more than the
            capped reads take, whether or not it can be tied to a tab. */
-        var tooWide = Strings(r, "fetches").Where(f => HoursAsked(f) > McpHelpers.MaxHoursBack).ToArray();
+        var tooWide = Strings(r, "fetches").Where(f => HoursAsked(f) > ReachOf(f)).ToArray();
         Assert.True(
             tooWide.Length == 0,
-            $"{tooWide.Length} reads the page made asked for more than {McpHelpers.MaxHoursBack} hours, the widest window the"
-            + " capped reads take (this list is every read the run made, so a read that cannot be tied to a tab is in it):\n"
+            $"{tooWide.Length} reads the page made asked for more hours than the read takes ({McpHelpers.MaxHoursBack} unless the"
+            + " read's row in WebReadReach says more; this list is every read the run made, so a read that cannot be tied to a tab is in it):\n"
             + string.Join("\n", tooWide.Take(40)));
 
         Assert.Empty(r.GetProperty("rejections").EnumerateArray());
@@ -89,9 +90,20 @@ and named ranged reads from each are seen at that range's hours. */
         }
     }
 
+    /// <summary>The real <c>/api/catalog</c> body, which the harness serves to the page: each read's <c>max_hours</c> is the one the
+    /// service serves, so a tab's reach in these tests is the product's, not a copy.</summary>
+    private static string CatalogJson() => DarlingWebEndpoints.BuildCatalogNode().ToJsonString();
+
     private static string[] Strings(JsonElement node, string name) =>
         node.GetProperty(name).EnumerateArray().Select(e => e.GetString()!).ToArray();
 
+    /// <summary>The hours the read in a fetched URL takes: its row in <see cref="WebReadReach"/>, else the common 168.</summary>
+    private static int ReachOf(string fetched)
+    {
+        var read = Regex.Match(fetched, @"/api/read/([a-z_0-9]+)", RegexOptions.CultureInvariant);
+        return read.Success && WebReadReach.All.TryGetValue(read.Groups[1].Value, out var row) ? row.MaxHours : McpHelpers.MaxHoursBack;
+    }
+
     private static readonly Regex s_hoursParam = new(@"[?&]hours=([0-9]+(?:\.[0-9]+)?)", RegexOptions.CultureInvariant);
 
     /// <summary>The hours a fetched URL asks for, or 0 when it takes no window.</summary>
@@ -115,9 +127,10 @@ private static readonly (string Engine, string[] Reads)[] s_witnesses =
     [Fact]
     public void TheBlockingTabNote_NamesTheWidestOfferedRange()
     {
-        if (!WebRangeKeptHistoryBehaviourTests.TryRun("offeredRanges:" + McpHelpers.MaxHoursBack, out var r)) return;
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("offeredRanges:" + McpHelpers.MaxHoursBack, out var r, CatalogJson())) return;
 
-        var widest = r.GetProperty("offered").EnumerateArray().Max(e => e.GetInt32());
+        /* The Blocking tab's own reach (#5562 review r1 M4): the number its note names is the widest range THIS tab offers. */
+        var widest = r.GetProperty("found").GetProperty("reaches").GetProperty("SQL Server blocking").GetInt32();
         Assert.True(widest % 24 == 0, $"The widest preset is {widest} hours, not a whole number of days, so this pin needs remapping.");
         var days = widest / 24;
         var notes = r.GetProperty("notes").EnumerateArray().Select(e => e.GetString()!).ToArray();
@@ -130,19 +143,169 @@ public void TheBlockingTabNote_NamesTheWidestOfferedRange()
         Assert.Single(notes, n => n.Contains("A Custom View can show more", System.StringComparison.Ordinal));
     }
 
-    /// <summary>The same rule read from <c>pages/server.js</c> (#5562): the page declares how far its reads reach (no wider than
-    /// <see cref="McpHelpers.MaxHoursBack"/>), hands that reach to the picker so a longer range is greyed out, and derives the
-    /// whole-hour presets it reads as plain <c>hours</c> from the picker module's presets, never a list of its own.</summary>
+    /// <summary>The same rule read from <c>pages/server.js</c> (#5562 review r1 M4): the page holds no reach of its own. A tab's
+    /// reach is the catalog's, read through <c>readsReachHours</c>; it is handed to the picker so a longer range is greyed out with
+    /// the tab's reason; and the whole-hour presets come from the picker module's presets, never a list of its own.</summary>
     [Fact]
-    public void TheOfferedRanges_InTheSource_AreNoWiderThanTheReadsTake()
+    public void TheOfferedRanges_InTheSource_AreTheTabsReachFromTheCatalog()
     {
         var server = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server.js");
-        var reach = Regex.Match(server, @"const PAGE_REACH_HOURS = ([0-9]+);");
-        Assert.True(reach.Success, "pages/server.js no longer declares PAGE_REACH_HOURS.");
-        Assert.InRange(int.Parse(reach.Groups[1].Value, CultureInfo.InvariantCulture), 1, McpHelpers.MaxHoursBack);
-        Assert.Contains("reachHours: PAGE_REACH_HOURS", server, System.StringComparison.Ordinal);
+        Assert.DoesNotContain("PAGE_REACH_HOURS", server, System.StringComparison.Ordinal);
+        Assert.Contains("readsReachHours(", server, System.StringComparison.Ordinal);
+        Assert.Contains("reachHours: tabReach(null, server)", server, System.StringComparison.Ordinal);
+        Assert.Contains("reachMessage:", server, System.StringComparison.Ordinal);
         Assert.Matches(@"const RANGE_OPTIONS = ROLLING_PRESETS", server);
-        Assert.Contains("hours <= PAGE_REACH_HOURS", server, System.StringComparison.Ordinal);
+        Assert.DoesNotContain("hours <= ", server.Split("function rangeOption")[0], System.StringComparison.Ordinal);
+    }
+
+    /// <summary>
+    /// A tab does not hand-type its hours (#5562 review r1 M4, ruling R2). Every tab names the windowed reads it makes
+    /// (<c>reachReads</c>), each name is a read the web serves, and no tab object, the registry or the server page carries a
+    /// number of hours as a reach: the only source of a number is the catalog's <c>max_hours</c>.
+    /// </summary>
+    [Fact]
+    public void ATab_NamesItsReads_AndNeverTypesItsHours()
+    {
+        var tabs = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tabs.js");
+        var findings = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "analysis-findings.js");
+        var server = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server.js");
+
+        var hand = new Regex(@"\b(reach|reachHours|reachReads|maxHours|max_hours)\s*[:=]\s*[0-9]", RegexOptions.CultureInvariant);
+        foreach (var (file, text) in new[] { ("server-tabs.js", tabs), ("analysis-findings.js", findings), ("server.js", server) })
+        {
+            var typed = hand.Matches(text).Select(m => m.Value).ToArray();
+            Assert.True(typed.Length == 0, $"{file} types a reach as a number ({string.Join("; ", typed)}); a tab's reach is the catalog's max_hours of its reachReads.");
+        }
+
+        /* Each registry tab declares reachReads (the whole registry is 12 + 8 tabs; the Recommendations tab lives in its own module). */
+        var declared = Regex.Matches(tabs, @"reachReads:\s*\[([^\]]*)\]", RegexOptions.CultureInvariant);
+        Assert.True(declared.Count >= 15, $"Only {declared.Count} tabs declare reachReads.");
+        Assert.Contains("reachReads: [\"get_analysis_findings\"]", findings, System.StringComparison.Ordinal);
+
+        var served = DarlingWebEndpoints.CatalogDescriptors.Keys.ToHashSet(System.StringComparer.Ordinal);
+        foreach (var name in declared.SelectMany(d => Regex.Matches(d.Groups[1].Value, "\"([a-z_]+)\"").Select(m => m.Groups[1].Value)).Distinct())
+        {
+            Assert.True(served.Contains(name), $"A tab's reachReads names {name}, which the web does not serve.");
+        }
+    }
+
+    /// <summary>
+    /// A tab's reach is the smallest <c>max_hours</c> among the reads it makes, from the real catalog. The I/O tab is made of
+    /// two 30-day trends and offers 30 days; the Activity tab shows the perfmon trend (7 days) beside them and stays at 7; the
+    /// Queries tab shows the query heatmap (7 days) and stays at 7; a tab with a list read stays at 7; and every tab's reach
+    /// equals the minimum computed here from the read table, so a tab with two reads takes the smaller. A tab that makes a
+    /// windowed read its <c>reachReads</c> does not name fails the run, because an unnamed read could lift the tab past it.
+    /// </summary>
+    [Fact]
+    public void ATabsReach_IsTheSmallestOfItsReads_FromTheCatalog()
+    {
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("offeredRanges:" + McpHelpers.MaxHoursBack, out var r, CatalogJson())) return;
+
+        var found = r.GetProperty("found");
+        var reaches = found.GetProperty("reaches");
+        Assert.Equal(720, reaches.GetProperty("SQL Server io").GetInt32());
+        Assert.Equal(McpHelpers.MaxHoursBack, reaches.GetProperty("SQL Server activity").GetInt32());
+        Assert.Equal(McpHelpers.MaxHoursBack, reaches.GetProperty("SQL Server queries").GetInt32());
+        Assert.Equal(McpHelpers.MaxHoursBack, reaches.GetProperty("SQL Server blocking").GetInt32());
+        Assert.Equal(McpHelpers.MaxHoursBack, reaches.GetProperty("SQL Server config").GetInt32());
+
+        /* The I/O tab offers 30 days and the Activity tab does not. */
+        var offeredBy = found.GetProperty("offeredBy");
+        Assert.Contains(720, offeredBy.GetProperty("SQL Server io").EnumerateArray().Select(e => e.GetInt32()));
+        Assert.DoesNotContain(720, offeredBy.GetProperty("SQL Server activity").EnumerateArray().Select(e => e.GetInt32()));
+
+        /* Every tab: the harness's reach equals the minimum of the reads' table rows (a read without a row is 168). */
+        foreach (var tab in reaches.EnumerateObject())
+        {
+            var reads = TabReads(tab.Name);
+            var expected = reads.Length == 0
+                ? McpHelpers.MaxHoursBack
+                : reads.Min(read => WebReadReach.All.TryGetValue(read, out var row) ? row.MaxHours : McpHelpers.MaxHoursBack);
+            Assert.True(expected == tab.Value.GetInt32(), $"{tab.Name}: the page gave {tab.Value.GetInt32()} hours, the smallest of its reads is {expected}.");
+        }
+
+        var undeclared = Strings(found, "undeclared");
+        Assert.True(undeclared.Length == 0, "These tabs made a windowed read their reachReads does not name:\n" + string.Join("\n", undeclared));
+    }
+
+    /// <summary>The reads a tab declares, from the registry source: the tab key is "engine id" as the harness names it.</summary>
+    private static string[] TabReads(string key)
+    {
+        var tabs = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tabs.js");
+        var postgres = key.StartsWith("PostgreSQL ", System.StringComparison.Ordinal);
+        var id = key[(key.LastIndexOf(' ') + 1)..];
+        var registry = tabs[tabs.IndexOf("export const POSTGRES_TABS", System.StringComparison.Ordinal)..];
+        var sql = tabs[..tabs.IndexOf("export const POSTGRES_TABS", System.StringComparison.Ordinal)];
+        var source = postgres ? registry : sql;
+        if (key.StartsWith("SQL Server recommendations", System.StringComparison.Ordinal))
+        {
+            return ["get_analysis_findings"];
+        }
+
+        var match = Regex.Match(source, "    id: \"" + Regex.Escape(id) + "\",.*?(?:reachReads: \\[([^\\]]*)\\])?\\s*,?\\s*build", RegexOptions.Singleline | RegexOptions.CultureInvariant);
+        return match.Success && match.Groups[1].Success
+            ? Regex.Matches(match.Groups[1].Value, "\"([a-z_]+)\"").Select(m => m.Groups[1].Value).ToArray()
+            : [];
+    }
+
+    /// <summary>
+    /// A range carried to a tab that reads less (#5562 review r1 M4, ruling R2): 20 days held on the I/O tab (30-day reach), then
+    /// the Wait Stats tab (7 days). The tab reads its own 7 days, ending where the range ends, and says so in its label and in a
+    /// notice on the page. The range stays held, so the I/O tab takes all of it again. A 30-day pick is refused on the tab that
+    /// cannot read it, with the tab's reason, and no read on that tab asks for more than 168 hours.
+    /// </summary>
+    [Fact]
+    public void ARangeCarriedToATabThatReadsLess_IsReadAtThatTabsReach_AndSaysSo()
+    {
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("tabReachCarried", out var r, CatalogJson())) return;
+
+        var found = r.GetProperty("found");
+        Assert.Equal(JsonValueKind.Null, found.GetProperty("holdTwentyDays").ValueKind);
+        Assert.Equal(480, found.GetProperty("ioTwentyDays").GetProperty("hours").GetInt32());
+        Assert.Equal(JsonValueKind.Null, found.GetProperty("ioTwentyDays").GetProperty("note").ValueKind);
+
+        var waits = found.GetProperty("waitsTwentyDays");
+        Assert.Equal(168, waits.GetProperty("hours").GetInt32());
+        Assert.StartsWith("last 7 days of ", waits.GetProperty("label").GetString(), System.StringComparison.Ordinal);
+        var note = waits.GetProperty("note").GetString()!;
+        Assert.Contains("longer than this tab reads", note, System.StringComparison.Ordinal);
+        Assert.Contains("up to 7 days", note, System.StringComparison.Ordinal);
+
+        /* The picker's own refusal on the tab that cannot read 30 days says why. */
+        Assert.Equal("This tab reads up to 7 days.", found.GetProperty("holdThirtyOnWaits").GetString());
+        Assert.Contains("up to 7 days", found.GetProperty("holdThirtyOnWaitsRange").GetProperty("error").GetString());
+
+        /* On the I/O tab 30 days is held whole; carried to Wait Stats it is read as 7 days, with the notice on the page. */
+        Assert.Equal(JsonValueKind.Null, found.GetProperty("holdThirtyOnIo").ValueKind);
+        Assert.Equal(720, found.GetProperty("ioThirty").GetProperty("hours").GetInt32());
+        Assert.Equal(JsonValueKind.Null, found.GetProperty("ioThirty").GetProperty("note").ValueKind);
+        var thirty = found.GetProperty("waitsThirty");
+        Assert.Equal(168, thirty.GetProperty("hours").GetInt32());
+        Assert.Contains("(last 30 days) is longer than this tab reads", thirty.GetProperty("note").GetString(), System.StringComparison.Ordinal);
+        Assert.Contains(thirty.GetProperty("note").GetString()!, Strings(r, "notices"));
+
+        var reads = Strings(found, "waitsReads");
+        Assert.NotEmpty(reads);
+        Assert.All(reads, read => Assert.True(HoursAsked(read) <= McpHelpers.MaxHoursBack, "The Wait Stats tab asked for more than it reads: " + read));
+        Assert.Empty(Strings(r, "errors"));
+    }
+
+    /// <summary>A wide range held for one server, then a server whose catalog the page has not read: the panels wait for the catalog and
+    /// read once at the tab's reach (720 hours on the I/O tab), instead of reading the common 168 hours first and the rest after.</summary>
+    [Fact]
+    public void AWideRange_OnAServerWhoseCatalogIsNotRead_WaitsForTheCatalog_AndReadsOnce()
+    {
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("tabReachWaits", out var r, CatalogJson())) return;
+
+        var found = r.GetProperty("found");
+        var fetches = Strings(found, "fetches");
+        var reads = fetches.Where(f => f.StartsWith("/api/read/", System.StringComparison.Ordinal)).ToArray();
+        var windowed = reads.Where(read => HoursAsked(read) > 0).ToArray();
+        Assert.NotEmpty(windowed);
+        Assert.All(windowed, read => Assert.Equal(720, HoursAsked(read)));
+        Assert.InRange(found.GetProperty("catalog").GetInt32(), 0, found.GetProperty("firstRead").GetInt32() - 1);
+        Assert.Empty(Strings(r, "notices"));
+        Assert.Empty(Strings(r, "errors"));
     }
 
     /// <summary>A custom start and end maps to the reads' window: <c>as_of</c> is the end and <c>hours</c> is the span rounded
diff --git a/Darling/Darling.Tests/web-kept-history-harness.mjs b/Darling/Darling.Tests/web-kept-history-harness.mjs
index 421e4c0624..4c64418fe2 100644
--- a/Darling/Darling.Tests/web-kept-history-harness.mjs
+++ b/Darling/Darling.Tests/web-kept-history-harness.mjs
@@ -98,9 +98,9 @@ let found = null;
 const editorScenario = scenario.startsWith("editor");
 /* The offeredRanges scenario also loads the server page (pages/server.js and the fleet page it imports). The page
    keeps its Range presets, and the widest of them that it hands tabNote, in module-private constants, so the scratch
-   copy appends one line exporting RANGE_OPTIONS and WIDEST_RANGE_HOURS, the same way the editor copy exports
+   copy appends one line exporting RANGE_OPTIONS and holdSpec, the same way the editor copy exports
    ensureFieldConfigs. */
-const serverPageScenario = scenario === "offeredRanges" || scenario.startsWith("custom") || scenario.startsWith("picker");
+const serverPageScenario = scenario === "offeredRanges" || scenario.startsWith("custom") || scenario.startsWith("picker") || scenario.startsWith("tabReach");
 const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "kept-history-"));
 let modules;
 try {
@@ -133,7 +133,7 @@ try {
   if (serverPageScenario) {
     fs.writeFileSync(
       path.join(scratch, "pages", "server.js"),
-      fs.readFileSync(path.join(jsDir, "pages", "server.js"), "utf8") + "\nexport { RANGE_OPTIONS, WIDEST_RANGE_HOURS, holdSpec };\n"
+      fs.readFileSync(path.join(jsDir, "pages", "server.js"), "utf8") + "\nexport { RANGE_OPTIONS, holdSpec };\n"
     );
   }
   const load = (rel) => import(pathToFileURL(path.join(scratch, rel)).href);
@@ -145,6 +145,7 @@ try {
     editor: editorScenario ? await load("editor.js") : null,
     server: serverPageScenario ? await load(path.join("pages", "server.js")) : null,
     timeRange: serverPageScenario ? await load("time-range.js") : null,
+    pageRange: serverPageScenario ? await load("page-range.js") : null,
   };
 } finally {
   fs.rmSync(scratch, { recursive: true, force: true });
@@ -434,12 +435,27 @@ const scenarios = {
   // listed by range, registry and tab. What each tab draws is mounted too, under a node that names its range and tab,
   // so a notice or an error the page shows at an offered range comes back saying where.
   offeredRanges: async () => {
+    /* The catalog (HARNESS_INPUT, the real /api/catalog body) gives each read's reach; a read without a row, and a run without a
+       catalog, take the scenario's value (the common 168 hours). A tab offers the presets within the smallest reach of its
+       `reachReads` (#5562 review r1 M4), and each read refuses what its own catalog row does not take. */
     const maxHours = Number(scenarioValue);
+    const catalog = INPUT || { reads: [] };
+    const readReach = (name) => {
+      const entry = (catalog.reads || []).find((r) => r.name === name);
+      return entry ? modules.pageRange.readsReachHours(catalog, [name]) : maxHours;
+    };
     answer = (url) => {
       const hours = Number(asked(url));
-      return hours > maxHours ? refusal(hours, maxHours, Math.round(maxHours / 24)) : data(PICKER_ROWS[tool(url)] || {});
+      const max = readReach(tool(url));
+      return hours > max ? refusal(hours, max, Math.round(max / 24)) : data(PICKER_ROWS[tool(url)] || {});
     };
-    offered = modules.server.RANGE_OPTIONS.map((option) => option.hours);
+    const tabReach = (tab) => (catalog.reads && tab.reachReads ? modules.pageRange.readsReachHours(catalog, tab.reachReads) : maxHours);
+    const allTabs = [["SQL Server", modules.tabs.SERVER_TABS], ["PostgreSQL", modules.tabs.POSTGRES_TABS]].flatMap(([engine, registry]) => registry.map((tab) => [engine, tab]));
+    /* `offered` is the presets EVERY tab offers; `reaches` is each tab's own longest, and `undeclared` the windowed reads a tab made
+       that its `reachReads` does not name (a list that missed one would lift the tab's reach past a read that refuses it). */
+    const common = Math.min(...allTabs.map(([, tab]) => tabReach(tab)));
+    offered = modules.server.RANGE_OPTIONS.filter((option) => option.hours <= common).map((option) => option.hours);
+    found = { reaches: {}, undeclared: [], offeredBy: {} };
     beyond = [];
     observed = [];
     notes = [];
@@ -447,6 +463,8 @@ const scenarios = {
     for (const option of modules.server.RANGE_OPTIONS) {
       for (const [engine, registry] of [["SQL Server", modules.tabs.SERVER_TABS], ["PostgreSQL", modules.tabs.POSTGRES_TABS]]) {
         for (const tab of registry) {
+          if (option.hours > tabReach(tab)) continue;
+          (found.offeredBy[engine + " " + tab.id] ||= []).push(option.hours);
           const before = fetches.length;
           const holder = new FakeNode("div");
           holder.where = option.label + ": " + engine + " " + tab.id + " tab";
@@ -457,8 +475,11 @@ const scenarios = {
             const url = new URL(fetched, "http://viewer.test");
             if (asked(url) !== null) {
               observed.push(option.hours + " " + engine + " " + tool(url));
+              if (!(tab.reachReads || []).includes(tool(url)) && !found.undeclared.includes(engine + " " + tab.id + " " + tool(url))) {
+                found.undeclared.push(engine + " " + tab.id + " " + tool(url));
+              }
             }
-            if (Number(asked(url)) > maxHours) {
+            if (Number(asked(url)) > readReach(tool(url))) {
               beyond.push(option.label + ": " + engine + " " + tab.id + " tab, " + tool(url) + " asked for " + asked(url) + " hours");
             }
           }
@@ -467,7 +488,8 @@ const scenarios = {
     }
     for (const [engine, registry] of [["SQL Server", modules.tabs.SERVER_TABS], ["PostgreSQL", modules.tabs.POSTGRES_TABS]]) {
       for (const tab of registry) {
-        const note = modules.tabs.tabNote(tab, modules.server.WIDEST_RANGE_HOURS);
+        found.reaches[engine + " " + tab.id] = tabReach(tab);
+        const note = modules.tabs.tabNote(tab, tabReach(tab));
         if (note) {
           notes.push(engine + " " + tab.id + ": " + note.textContent);
         }
@@ -606,6 +628,68 @@ Object.assign(scenarios, {
   },
 });
 
+/* ── per-tab reach on the server page (#5562 review r1 M4) ──
+   The answer to /api/catalog is HARNESS_INPUT, the real catalog body, so a tab's reach is the one the service serves. */
+const tabReachAnswers = () => {
+  const catalog = INPUT || { reads: [] };
+  answer = (url) => {
+    if (url.pathname === "/api/fleet") return data({ cards: [] });
+    if (url.pathname === "/api/catalog") return data(catalog);
+    if (url.pathname.startsWith("/api/read/")) {
+      const max = modules.pageRange.readsReachHours(catalog, [tool(url)]);
+      const hours = Number(asked(url));
+      return hours > max ? refusal(hours, max, Math.round(max / 24)) : data({});
+    }
+    return data({});
+  };
+};
+const tabPage = async (server, tabId) => {
+  const holder = new FakeNode("div");
+  modules.server.renderServer(holder, server, tabId);
+  await settleFast();
+  return holder;
+};
+const HOURS = 3600000;
+Object.assign(scenarios, {
+  // A 30 day or 20 day range held on the tab that reads 30 days, then carried to a tab that reads 7: that tab reads its own reach, says so
+  // in a notice and in its label, refuses the range in its own picker, and keeps the range held for the tab that takes it.
+  tabReachCarried: async () => {
+    tabReachAnswers();
+    const tr = modules.timeRange;
+    await tabPage("SRV1", "io");
+    const out = { ioFirst: modules.server.rangeContext(NOW).hours };
+    out.holdTwentyDays = modules.server.holdSpec("SRV1", tr.relativeSpec(480 * HOURS), NOW);
+    out.ioTwentyDays = { hours: modules.server.rangeContext(NOW).hours, note: modules.server.reachNoteText(NOW) };
+    await tabPage("SRV1", "waits");
+    const twenty = modules.server.rangeContext(NOW);
+    out.waitsTwentyDays = { hours: twenty.hours, label: twenty.label, custom: twenty.custom === true, note: modules.server.reachNoteText(NOW) };
+    out.holdThirtyOnWaits = modules.server.holdSpec("SRV1", tr.relativeSpec(720 * HOURS), NOW);
+    out.holdThirtyOnWaitsRange = modules.server.resolveCustomRange(NOW - 720 * HOURS, NOW, NOW);
+    await tabPage("SRV1", "io");
+    out.holdThirtyOnIo = modules.server.holdSpec("SRV1", tr.relativeSpec(720 * HOURS), NOW);
+    out.ioThirty = { hours: modules.server.rangeContext(NOW).hours, note: modules.server.reachNoteText(NOW) };
+    const before = fetches.length;
+    const holder = await tabPage("SRV1", "waits");
+    const thirty = modules.server.rangeContext(NOW);
+    out.waitsThirty = { hours: thirty.hours, label: thirty.label, custom: thirty.custom === true, note: modules.server.reachNoteText(NOW) };
+    out.waitsReads = fetches.slice(before).filter((f) => f.startsWith("/api/read/"));
+    found = out;
+    return [holder];
+  },
+  // A wide range held on one server, then a server whose catalog is not read yet: the panels wait for the catalog and read once, at the tab's
+  // reach, instead of reading 7 days and then the rest.
+  tabReachWaits: async () => {
+    tabReachAnswers();
+    await tabPage("SRV1", "io");
+    modules.server.holdSpec("SRV1", modules.timeRange.relativeSpec(720 * HOURS), NOW);
+    const before = fetches.length;
+    const holder = await tabPage("SRV2", "io");
+    const after = fetches.slice(before);
+    found = { fetches: after, firstRead: after.findIndex((f) => f.startsWith("/api/read/")), catalog: after.findIndex((f) => f.startsWith("/api/catalog")) };
+    return [holder];
+  },
+});
+
 const chosen = scenarios[scenario];
 if (!chosen) throw new Error("unknown scenario " + scenario);
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
index 9543e101de..ebcab2b58a 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/page-range.js
@@ -125,8 +125,20 @@ export function pageRangePicker(opts) {
   return { picker, ready };
 }
 
+/**
+ * How far back a set of reads all reach, in hours: the smallest catalog `max_hours` among them (#5562 review r1 M4, ruling R2). A page
+ * that shows several reads at one range (a server-page tab) can only offer a range every one of them takes, so the shortest reach wins.
+ * A read with no catalog row, an empty list and a catalog that could not be read all give the common 168 hours: the page never offers
+ * a range a read has not said it takes. The number comes from the catalog, the validators' own table, never from the page.
+ */
+export function readsReachHours(catalog, reads) {
+  const entries = catalog && Array.isArray(catalog.reads) ? catalog.reads : [];
+  if (!Array.isArray(reads) || reads.length === 0) return reachHours(null);
+  return Math.min(...reads.map((name) => reachHours(entries.find((r) => r && r.name === name) || null)));
+}
+
 /** The reach as the longest quick choice, when it is longer than the shared list's 30 days (#5562 review r1 M5, ruling R8). */
-function offerReach(picker) {
+export function offerReach(picker) {
   const hours = picker.reachHours();
   if (hours * HOUR_MS > ROLLING_PRESETS[ROLLING_PRESETS.length - 1].spanMs) picker.setExtraPresets([relativeSpec(hours * HOUR_MS)]);
 }
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/analysis-findings.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/analysis-findings.js
index 3469d3caa0..b24737dfd1 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/analysis-findings.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/analysis-findings.js
@@ -192,6 +192,8 @@ export function renderFindings(server, res) {
 export const analysisFindingsTab = {
   id: "recommendations",
   label: "Recommendations",
+  /* The windowed reads this tab makes, so the server page reads its reach from the catalog (#5562 review r1 M4). */
+  reachReads: ["get_analysis_findings"],
   build: (server, ctx) => {
     const body = el("div", { class: "panel-body" }, [loadingStrip()]);
     (async () => {
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
index 8837ce625c..77f4fc9156 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
@@ -1074,6 +1074,10 @@ export const SERVER_TABS = [
     id: "overview",
     label: "Overview",
     collector: "cpu_utilization",
+    reachReads: [
+      "get_analysis_findings", "get_blocking_trend", "get_cpu_utilization", "get_deadlock_trend",
+      "get_file_io_trend", "get_memory_trend"
+    ],
     build: (server, ctx) => [
       stat("Overview", "get_server_summary", { server }, OVERVIEW_STATS, SNAPSHOT, 2),
       stat("Server Properties", "get_server_properties", { server }, PROPERTY_STATS, SNAPSHOT, 2),
@@ -1123,6 +1127,9 @@ export const SERVER_TABS = [
     id: "waits",
     label: "Wait Stats",
     collector: "wait_stats",
+    reachReads: [
+      "get_latch_stats", "get_spinlock_stats", "get_wait_stats", "get_wait_trend", "get_waiting_tasks"
+    ],
     build: (server, ctx) => [
       waitsPanel(server, ctx),
       table(
@@ -1161,6 +1168,9 @@ export const SERVER_TABS = [
     id: "cpu",
     label: "CPU",
     collector: "cpu_utilization",
+    reachReads: [
+      "get_cpu_utilization", "get_server_trend", "get_top_procedures_by_cpu", "get_top_queries_by_cpu"
+    ],
     build: (server, ctx) => [
       line("CPU Utilization", "get_cpu_utilization", { server, hours: ctx.hours }, "samples", "sample_time", CPU_SERIES, {
         subtitle: ctx.label,
@@ -1213,6 +1223,10 @@ export const SERVER_TABS = [
     id: "memory",
     label: "Memory",
     collector: "memory_stats",
+    reachReads: [
+      "get_memory_grants", "get_memory_pressure_events", "get_memory_trend", "get_plan_cache_bloat",
+      "get_resource_semaphore", "get_server_trend"
+    ],
     build: (server, ctx) => [
       stat("Memory", "get_memory_stats", { server }, MEMORY_STATS, SNAPSHOT, 2),
       line("Memory Trend", "get_memory_trend", { server, hours: ctx.hours }, "trend", "time", MEMORY_SERIES, {
@@ -1312,6 +1326,11 @@ export const SERVER_TABS = [
       "is one of the desktop-viewer features this page does not have. A deadlock graph can be drawn from its row. This page shows at most " +
       daysText(widestHours) +
       ". A Custom View can show more blocking and deadlock history.",
+    reachReads: [
+      "get_blocked_process_xml", "get_blocking", "get_blocking_stats", "get_blocking_trend",
+      "get_current_waits_trend", "get_deadlock_detail", "get_deadlock_trend", "get_deadlocks",
+      "get_lock_wait_trend"
+    ],
     build: (server, ctx) => [
       line("Blocking Events", "get_blocking_trend", { server, hours: ctx.hours }, "trend", "time", COUNT_SERIES, {
         subtitle: ctx.label,
@@ -1448,6 +1467,9 @@ export const SERVER_TABS = [
     id: "io",
     label: "File I/O",
     collector: "file_io_stats",
+    reachReads: [
+      "get_file_io_trend", "get_tempdb_trend"
+    ],
     build: (server, ctx) => [
       fileIoPanel(server, ctx),
       table(
@@ -1507,6 +1529,12 @@ export const SERVER_TABS = [
       "Execution-plan analysis, the query heatmap, cached-plan retrieval and actual-plan re-execution are " +
       "desktop-viewer features — they need a plan renderer and a command back to the monitored server, neither " +
       "of which this read-only web seat has.",
+    reachReads: [
+      "get_active_queries", "get_long_query_completions", "get_plan_corrections", "get_procedure_duration_trend",
+      "get_query_duration_trend", "get_query_heatmap", "get_query_store_clutter",
+      "get_query_store_duration_trend", "get_query_store_regressions", "get_query_store_top", "get_query_trend",
+      "get_top_procedures_by_cpu", "get_top_queries_by_cpu"
+    ],
     build: (server, ctx) => [
       activeQueriesPanel(server, ctx),
       /* #2484: the viewer's Performance Trends tab is four charts over three reads. Duration and the
@@ -1790,6 +1818,9 @@ export const SERVER_TABS = [
   {
     id: "changes",
     label: "Config Changes",
+    reachReads: [
+      "get_database_config_changes", "get_server_config_changes", "get_trace_flag_changes"
+    ],
     build: (server, ctx) => [
       table(
         "Server Configuration Changes",
@@ -1824,6 +1855,9 @@ export const SERVER_TABS = [
   {
     id: "activity",
     label: "Activity",
+    reachReads: [
+      "get_job_history", "get_perfmon_trend", "get_server_trend"
+    ],
     build: (server, ctx) => [
       perfmonPanel(server, ctx),
       sessionStatsTrendPanel(server, ctx),
@@ -1874,6 +1908,12 @@ export const SERVER_TABS = [
     note:
       "These are the system_health session and default trace, parsed on read. The desktop viewer additionally " +
       "charts the corruption and contention counters hour-by-hour; here they are the raw parsed rows.",
+    reachReads: [
+      "get_default_trace_events", "get_health_parser_cpu_tasks", "get_health_parser_io_issues",
+      "get_health_parser_memory_broker", "get_health_parser_memory_conditions",
+      "get_health_parser_memory_node_oom", "get_health_parser_scheduler_issues",
+      "get_health_parser_severe_errors", "get_health_parser_significant_waits", "get_health_parser_system_health"
+    ],
     build: (server, ctx) => [
       ...fanout("get_health_parser_system_health", { server, hours: ctx.hours, limit: 50 }, [
         {
@@ -1988,6 +2028,9 @@ export const SERVER_TABS = [
   {
     id: "health",
     label: "Collection Health",
+    reachReads: [
+      "get_collection_log"
+    ],
     build: (server, ctx) => [
       /* One read, three panels. get_collection_health rolls up seven days of collector logs AND computes sweep
          pressure; these are three slices of that single payload, so three descriptors meant running the tab's
@@ -2069,6 +2112,10 @@ export const POSTGRES_TABS = [
   {
     id: "overview",
     label: "Overview",
+    reachReads: [
+      "get_analysis_findings", "get_collection_log", "get_pg_autovacuum_health", "get_pg_cpu_utilization",
+      "get_pg_extensions", "get_pg_replication_slots", "get_pg_wraparound_risk", "get_pg_xmin_horizon"
+    ],
     build: (server, ctx) => [
       /* The vitals are the three Tier 0 outage predictors plus the backlog that feeds two of them, as tiles
          rather than the tables the owning tabs carry: the question on a triage screen is "is anything wrong",
@@ -2240,6 +2287,11 @@ export const POSTGRES_TABS = [
       "not: it comes from Amazon Aurora's aurora_stat_statements(), which core PostgreSQL has in no version, " +
       "so on a stock PostgreSQL target that one panel is permanently empty and says so in its own words " +
       "while the two above it keep working.",
+    reachReads: [
+      "get_pg_blocking", "get_pg_column_stats", "get_pg_database_stats", "get_pg_database_trend",
+      "get_pg_deadlocks", "get_pg_lock_stats", "get_pg_log_events", "get_pg_plan_capture_readiness",
+      "get_pg_plans", "get_pg_predicate_stats", "get_pg_query_duration_trend", "get_pg_top_queries"
+    ],
     build: (server, ctx) => [
       /* One read, three panels, and the FIRST of them is the denominator. get_pg_blocking is a periodic SAMPLE,
          not an event log: PostgreSQL records nothing unless asked, so "no chains" is ambiguous between a quiet
@@ -2476,6 +2528,9 @@ export const POSTGRES_TABS = [
       "which is where the fix has to be made, and only it says whether that session pins anything at all: an " +
       "open transaction holding no snapshot and no transaction id costs vacuum nothing, however long it has " +
       "been idle.",
+    reachReads: [
+      "get_pg_autovacuum_health", "get_pg_session_states", "get_pg_wraparound_risk", "get_pg_xmin_horizon"
+    ],
     build: (server, ctx) => [
       /* Ordered by CAUSE, not by severity: session, then horizon, then backlog, then headroom.
 
@@ -2597,6 +2652,9 @@ export const POSTGRES_TABS = [
       "aurora_stat_system_waits(), which core PostgreSQL has in no version. On a stock PostgreSQL target this " +
       "tab is permanently empty and the panel says so in its own words. The tab is here anyway so that the tab " +
       "set does not change shape between two PostgreSQL servers in the same fleet.",
+    reachReads: [
+      "get_pg_kernel_stats", "get_pg_wait_sampling", "get_pg_wait_stats", "get_pg_wait_trend"
+    ],
     build: (server, ctx) => [
       table(
         "Wait Events",
@@ -2654,6 +2712,9 @@ export const POSTGRES_TABS = [
       "per-file grid here and the shape is deliberately not the SQL Server one. On Aurora the whole write side " +
       "is NULL — backends there do not write data files, storage does — so the write columns read as blank " +
       "rather than as zero, which would claim a measurement never taken.",
+    reachReads: [
+      "get_pg_buffer_usage", "get_pg_io_stats", "get_pg_io_trend", "get_pg_write_stats"
+    ],
     build: (server, ctx) => [
       ...fanout("get_pg_io_stats", { server, hours: ctx.hours, limit: 20 }, [
         {
@@ -2717,6 +2778,9 @@ export const POSTGRES_TABS = [
   {
     id: "replication",
     label: "Replication",
+    reachReads: [
+      "get_pg_replication_slots", "get_pg_replication_stats"
+    ],
     build: (server, ctx) => [
       ...fanout("get_pg_replication_slots", { server, hours: ctx.hours }, [
         {
@@ -2763,6 +2827,9 @@ export const POSTGRES_TABS = [
   {
     id: "storage",
     label: "Storage",
+    reachReads: [
+      "get_pg_index_bloat", "get_pg_index_usage", "get_pg_table_bloat"
+    ],
     build: (server, ctx) => [
       ...fanout("get_pg_table_bloat", { server, hours: ctx.hours, limit: 25 }, [
         {
@@ -2867,6 +2934,9 @@ export const POSTGRES_TABS = [
   {
     id: "config",
     label: "Configuration",
+    reachReads: [
+      "get_pg_server_config_changes"
+    ],
     build: (server, ctx) => [
       table(
         "Configuration Changes",
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
index 444cb30016..51b50064a6 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
@@ -45,32 +45,51 @@
  * subtitle rather than inheriting a label that would misdescribe them.
  */
 
-import { el, mount, apiGetFleet, bandClass, loadingStrip, setActiveRange, setActiveDatabaseFilter, localTime } from "../util.js";
+import { el, mount, apiGetFleet, bandClass, loadingStrip, noticeStrip, setActiveRange, setActiveDatabaseFilter, localTime } from "../util.js";
 import { getDatabaseFilter } from "../viewer-local.js";
 import { databaseFilterControl, databaseFilterUnavailable } from "./database-filter.js";
 import { setPanelSignal } from "../panels.js";
 import { serverTabsFor, isPostgresTarget, findServerTab, tabNote } from "./server-tabs.js";
 import { metricBands } from "./fleet.js";
-import { timeRangePicker } from "../time-range-picker.js";
-import { serverCatalog, collectorIntervalFromCatalog } from "../page-range.js";
-import { browserZone, resolveSpec, relativeSpec, fixedSpec, specName, wholeHours, readWindow, reachRefusal, ROLLING_PRESETS, MINIMUM_SPAN_MS } from "../time-range.js";
-
-/** How far back this page's reads reach, in hours. All but three ranged reads on these tabs (the collection log, current waits and
- *  blocking stats) take at most McpHelpers.MaxHoursBack (168) hours, so a longer choice was never served: those panels asked again
- *  for 7 days and said so (#2802). The picker greys out a longer range and says why. Custom Views offer longer windows: their
- *  composed panels read the store directly, through rollups for the query tables. A catalog `max_hours` per read (#5562) lets a
- *  page that shows one read raise this for that read; this page shows many, so it keeps the common 168.
- *  WebServerPageRangeTests runs every option through every tab of both registries. */
-const PAGE_REACH_HOURS = 168;
-
-/** The short presets that are a whole number of hours within the reach: the ranges the reads take as `hours` alone, with no
- *  trimming. Every other range (30 minutes, Yesterday, 2 days 3 hours, a typed pair) is fetched as whole hours back from its
- *  end and trimmed to the exact pair, the custom path below. */
+import { timeRangePicker, DEFAULT_REACH_HOURS } from "../time-range-picker.js";
+import { serverCatalog, collectorIntervalFromCatalog, readsReachHours, offerReach } from "../page-range.js";
+import { browserZone, resolveSpec, relativeSpec, fixedSpec, specName, wholeHours, readWindow, reachText, ROLLING_PRESETS, MINIMUM_SPAN_MS } from "../time-range.js";
+
+/* How far back the tab on screen reaches (#5562 review r1 M4, ruling R2). Each tab lists the windowed reads it makes (`reachReads` in
+   server-tabs.js: names, never hours), and its reach is the smallest `max_hours` the catalog gives them (tabReach below), so a tab
+   made of reads that take 30 days offers 30 days, and a tab that also shows a list that takes 7 stays at 7. A read with no catalog
+   row, a tab that lists none and a catalog that cannot be read all give the common DEFAULT_REACH_HOURS (168): the page never offers
+   a range a read has not said it takes. The picker greys out a longer range and says why, and a range carried over from a tab that
+   reads further is read at this tab's reach with a notice saying so (reachNoteText), never silently (#2802 did the same per panel).
+   WebServerPageRangeTests runs every offered range through every tab of both registries. */
+
+/** The short presets that are a whole number of hours: the ranges the reads take as `hours` alone, with no trimming. Every other
+ *  range (30 minutes, Yesterday, 2 days 3 hours, a typed pair) is fetched as whole hours back from its end and trimmed to the exact
+ *  pair, the custom path below. A tab takes the ones within its own reach. */
 const RANGE_OPTIONS = ROLLING_PRESETS.map((spec) => wholeHours(spec))
-  .filter((hours) => hours != null && hours <= PAGE_REACH_HOURS)
-  .map((hours) => ({ hours, label: hours === 1 ? "last hour" : hours > 24 && hours % 24 === 0 ? "last " + hours / 24 + " days" : "last " + hours + " hours" }));
+  .filter((hours) => hours != null)
+  .map((hours) => rangeOption(hours));
 
-const WIDEST_RANGE_HOURS = Math.max(...RANGE_OPTIONS.map((o) => o.hours));
+function rangeOption(hours) {
+  return { hours, label: hours === 1 ? "last hour" : hours > 24 && hours % 24 === 0 ? "last " + hours / 24 + " days" : "last " + hours + " hours" };
+}
+
+/* The catalog each server answered with, or null where it could not be read: the answer, not the promise, so a tab's reach is a plain
+   function (tabReach) that holds until the catalog is known. The reads' reach belongs to the read, not the server, so one answer per
+   server is enough for the page's life. A catalog that could not be read is not kept: the next tab or range change asks again. */
+const catalogsRead = new Map();
+/* Servers whose catalog could not be read when a wide range waited for it: they read at the common reach, and do not wait again. */
+const catalogGaveUp = new Set();
+
+/** How far back a tab's reads all reach, in hours (the smallest catalog `max_hours` among its `reachReads`). */
+function tabReach(tab = current.tab, server = current.server) {
+  return readsReachHours(server ? catalogsRead.get(server) : null, tab && tab.reachReads);
+}
+
+/** The refusal for a span past the tab's reach, or null. */
+function tabReachRefusal(spanMs, reach = tabReach()) {
+  return spanMs > reach * HOUR_MS ? "This tab reads up to " + reachText(reach) + "." : null;
+}
 
 /* Module state, deliberately not persisted — see the header comment. `gridNode` + the current server/tab let the
    range control redraw only the panels, so changing the window does not flash the header or refetch /api/fleet. */
@@ -122,13 +141,13 @@ const HOUR_MS = 3600000;
  * pair (under 5 minutes, reversed, in the future, past the reach), else `{ hours, asOf, live, startMs, endMs }`; `asOf`
  * is null for a live range, whose reads are anchored at the server's own clock.
  */
-export function resolveCustomRange(startMs, endMs, nowMs) {
+export function resolveCustomRange(startMs, endMs, nowMs, reach = tabReach()) {
   if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return { error: "Enter both a start and an end." };
   if (endMs <= startMs) return { error: "The end must be after the start." };
   if (endMs > nowMs + LIVE_SLACK_MS) return { error: "The end cannot be in the future." };
   const span = endMs - startMs;
   if (span < MINIMUM_SPAN_MS) return { error: "The shortest range is 5 minutes. Drag across a chart to look at a shorter span." };
-  const tooLong = reachRefusal(span, PAGE_REACH_HOURS);
+  const tooLong = tabReachRefusal(span, reach);
   if (tooLong) return { error: tooLong };
   const live = endMs >= nowMs - LIVE_SLACK_MS;
   return { hours: Math.max(1, Math.ceil(span / HOUR_MS)), asOf: live ? null : new Date(endMs).toISOString(), live, startMs, endMs };
@@ -139,7 +158,7 @@ export function resolveCustomRange(startMs, endMs, nowMs) {
 function holdSpec(server, spec, nowMs) {
   const resolved = resolveSpec(spec, nowMs, browserZone());
   if (!resolved.ok) return resolved.error.message;
-  const tooLong = reachRefusal(resolved.range.spanMs, PAGE_REACH_HOURS);
+  const tooLong = tabReachRefusal(resolved.range.spanMs);
   if (tooLong) return tooLong;
   const hours = wholeHours(spec);
   if (hours != null && RANGE_OPTIONS.some((o) => o.hours === hours)) {
@@ -168,10 +187,14 @@ export function applyCustomRange(server, startMs, endMs, nowMs = Date.now(), { r
  *  every read of this server inside it is anchored and trimmed there. */
 export function rangeContext(nowMs = Date.now()) {
   const custom = current.server ? customRanges.get(current.server) : null;
+  const reach = tabReach();
   if (custom) {
     const resolved = resolveSpec(custom.spec, nowMs, browserZone());
-    if (resolved.ok && !reachRefusal(resolved.range.spanMs, PAGE_REACH_HOURS)) {
-      const range = resolved.range;
+    if (resolved.ok) {
+      /* A range carried over from a tab that reads further is read at THIS tab's reach: the last stretch of it, ending where it ends.
+         The range stays held (the next tab may take all of it), and reachNoteText says what happened (#5562 review r1 M4). */
+      const cut = tabReachRefusal(resolved.range.spanMs, reach) != null;
+      const range = cut ? { ...resolved.range, startMs: resolved.range.endMs - reach * HOUR_MS, spanMs: reach * HOUR_MS } : resolved.range;
       const w = readWindow(range);
       setActiveRange({ server: current.server, hours: w.hours, startMs: range.startMs, endMs: range.endMs, asOf: w.asOf });
       /* Totals and rankings are read over whole hours back from the end, so they can begin earlier than the picked start:
@@ -179,15 +202,17 @@ export function rangeContext(nowMs = Date.now()) {
       const aggregateFrom = range.endMs - w.hours * HOUR_MS;
       const rounded = aggregateFrom < range.startMs ? "; totals and rankings aggregate from " + localTime(new Date(aggregateFrom).toISOString()) : "";
       const times = localTime(new Date(range.startMs).toISOString()) + " to " + (range.live ? "now" : localTime(new Date(range.endMs).toISOString()));
-      const named = custom.spec.kind === "relative" || custom.spec.kind === "calendar" ? specName(custom.spec).toLowerCase() : "custom";
+      const picked = custom.spec.kind === "relative" || custom.spec.kind === "calendar" ? specName(custom.spec).toLowerCase() : "custom";
+      const named = cut ? "last " + reachText(reach) + " of " + picked : picked;
       return { hours: w.hours, label: named + ": " + times + rounded, custom: true };
     }
-    if (resolved.ok) customRanges.delete(current.server);
   }
   setActiveRange(null);
-  const opt = RANGE_OPTIONS.find((o) => o.hours === pageHours) || RANGE_OPTIONS.find((o) => o.hours === 24) || RANGE_OPTIONS[0];
-  /* A held range that cannot resolve right now (Today in its first five minutes) is kept, not dropped: the label says so and names the
-     window shown instead, and the range reads again once it can (#5562 review r1 L3). */
+  /* A held preset longer than this tab reads is read at the tab's reach (reachNoteText says so). */
+  const held = RANGE_OPTIONS.find((o) => o.hours === pageHours) || RANGE_OPTIONS.find((o) => o.hours === 24) || RANGE_OPTIONS[0];
+  const opt = held.hours > reach ? rangeOption(reach) : held;
+  /* A held range that cannot resolve right now (a calendar period that ends at or before its start, Today at exactly midnight, R9) is
+     kept, not dropped: the label says so and names the window shown instead, and the range reads again once it can (#5562 review r1 L3). */
   if (custom) {
     const unresolved = resolveSpec(custom.spec, nowMs, browserZone());
     if (!unresolved.ok) return { hours: opt.hours, label: specName(custom.spec).toLowerCase() + " cannot be read yet (" + unresolved.error.message + "); showing " + opt.label };
@@ -195,6 +220,22 @@ export function rangeContext(nowMs = Date.now()) {
   return { hours: opt.hours, label: opt.label };
 }
 
+/** The sentence for a range the reader picked that is longer than the tab on screen reads, or null when the tab takes all of it. The
+ *  tab reads its own reach instead, so the page says so beside the panels, never silently (#5562 review r1 M4, ruling R2). */
+export function reachNoteText(nowMs = Date.now()) {
+  const reach = tabReach();
+  const custom = current.server ? customRanges.get(current.server) : null;
+  let spanMs = pageHours * HOUR_MS;
+  let picked = rangeOption(pageHours).label;
+  const resolved = custom ? resolveSpec(custom.spec, nowMs, browserZone()) : null;
+  if (resolved && resolved.ok) {
+    spanMs = resolved.range.spanMs;
+    picked = custom.spec.kind === "relative" || custom.spec.kind === "calendar" ? specName(custom.spec).toLowerCase() : "custom range";
+  }
+  if (tabReachRefusal(spanMs, reach) == null) return null;
+  return "The range you picked (" + picked + ") is longer than this tab reads. This tab reads up to " + reachText(reach) + ", so it shows the last " + reachText(reach) + " of that range.";
+}
+
 /* Set when the poll ticks over a fixed custom range: the panels the previous render drew stay on screen (see
    renderServer). `gridKey` names the server and tab that grid shows. */
 let keepGrid = false;
@@ -237,8 +278,10 @@ export function renderServer(main, server, tabId, opts) {
 
   /* The bar and the note share one slot because both are decided by the same card. */
   const tabsSlot = el("div", { class: "subtabs-slot" }, [loadingStrip()]);
+  /* The notice for a carried-over range this tab reads only part of (reachNoteText), between the tab bar and the panels. */
+  reachSlot = el("div", { class: "reach-note-slot" });
   if (!keep) gridNode = el("div", { class: "panel-grid" });
-  mount(main, [head, whySlot, tabsSlot, gridNode]);
+  mount(main, [head, whySlot, tabsSlot, reachSlot, gridNode]);
 
   /* Seen this server before? Then its engine is already known and the page paints now — no loading strip, and
      the tab's panels start fetching in this tick, which is what keeps the 60s poll and a sub-tab click feeling
@@ -294,16 +337,39 @@ function paintTabs(tabsSlot, server, tabId, card) {
   const tab = findServerTab(tabId, tabs);
   current = { server, tab };
   gridKey = server + "|" + (tabId || "");
-  mount(tabsSlot, [subtabBar(server, tab, tabs), tabNote(tab, WIDEST_RANGE_HOURS)]);
+  tabNoteSlot = el("div", { class: "tab-note-slot" }, [tabNote(tab, tabReach())]);
+  mount(tabsSlot, [subtabBar(server, tab, tabs), tabNoteSlot]);
   redrawPanels();
   return tabs;
 }
 
+/* The two slots the tab's reach decides: its note (which names how far back the page shows) and the carried-over-range notice. */
+let tabNoteSlot = null;
+let reachSlot = null;
+
+/** Show the reach the catalog gave the tab on screen: the picker's longest choice, the tab note's number and the carried-over-range
+ *  notice. Run on every redraw and again when the catalog arrives. */
+function applyTabReach() {
+  const tab = current.tab;
+  if (!tab || !current.server) return;
+  const reach = tabReach();
+  if (rangePicker && rangePicker.reachHours() !== reach) {
+    rangePicker.setReach(reach);
+    offerReach(rangePicker);
+  }
+  if (tabNoteSlot) mount(tabNoteSlot, [tabNote(tab, reach)]);
+  if (reachSlot) {
+    const note = reachNoteText();
+    mount(reachSlot, note ? [noticeStrip(note)] : []);
+  }
+}
+
 /** (Re)fill the panel grid for the current server + tab at the current range. No refetch of anything else. */
 function redrawPanels() {
   if (!gridNode || !current.tab || !current.server) return;
 
-  /* Before the keepGrid return: a poll that keeps the panels still built a new picker, which needs its note. */
+  /* Before the keepGrid return: a poll that keeps the panels still built a new picker, which needs its reach and its note. */
+  applyTabReach();
   applySampleNote();
 
   if (keepGrid) {
@@ -311,6 +377,21 @@ function redrawPanels() {
     return;
   }
 
+  /* A range longer than the common reach cannot be read until the tab's reach is known (it may take the whole range, or only the
+     last 7 days of it), so the panels wait for the catalog rather than read twice. A held range within the common reach reads now. */
+  if (!catalogsRead.has(current.server) && !catalogGaveUp.has(current.server) && heldSpanMs() > DEFAULT_REACH_HOURS * HOUR_MS) {
+    const server = current.server;
+    const tab = current.tab;
+    if (panelAbort) panelAbort.abort();
+    mount(gridNode, [loadingStrip()]);
+    serverCatalog(server).catch(() => null).then((catalog) => {
+      if (catalog) catalogsRead.set(server, catalog);
+      else catalogGaveUp.add(server);
+      if (server === current.server && tab === current.tab) redrawPanels();
+    });
+    return;
+  }
+
   /* Every redraw replaces the whole panel grid — a fresh render (poll tick or sub-tab click), or the range
      picker choosing a new window for the SAME tab — so it starts a whole new batch of panel reads and the
      PREVIOUS batch's, if still pending, are now for nobody. #4191: aborting them here is what stopped the
@@ -368,13 +449,14 @@ function subtabBar(server, active, tabs) {
 
 /** The time-range picker (time-range-picker.js): the short presets, the calendar periods, a typed range and a date pick, in the
  *  browser's zone, the zone every time on this page uses. Changing it redraws the panels in place, exactly like the fleet page's
- *  sort. A range longer than the reads take (PAGE_REACH_HOURS) is greyed out with the reason. */
+ *  sort. A range longer than the tab's reads take (tabReach) is greyed out with the reason. */
 function rangeControl() {
   const server = current.server;
   const saved = customRanges.get(server);
   const picker = timeRangePicker({
     spec: saved ? saved.spec : relativeSpec(pageHours * HOUR_MS),
-    reachHours: PAGE_REACH_HOURS,
+    reachHours: tabReach(null, server),
+    reachMessage: (hours) => "This tab reads up to " + reachText(hours) + ".",
     label: "Time range",
     onChange: (spec) => {
       if (holdSpec(server, spec, Date.now()) == null) redrawPanels();
@@ -396,19 +478,29 @@ function applySampleNote() {
   const tab = current.tab;
   const server = current.server;
   if (!picker) return;
-  if (!tab || !tab.collector || !server) {
+  if (!tab || !server) {
     picker.setSampleInterval(null);
     return;
   }
+  /* The same catalog answer gives the tab its reach (M4) and its collector's interval (R3), so it is read for every tab. */
   serverCatalog(server).then((catalog) => {
+    if (catalog) catalogsRead.set(server, catalog);
     if (picker !== rangePicker || tab !== current.tab || server !== current.server) return;
-    picker.setSampleInterval(collectorIntervalFromCatalog(catalog, tab.collector));
+    applyTabReach();
+    picker.setSampleInterval(tab.collector ? collectorIntervalFromCatalog(catalog, tab.collector) : null);
   }).catch(() => {
-    /* A catalog that cannot be read shows no note (#5562 review r1 L2); the next tab or range change asks again. */
+    /* A catalog that cannot be read shows no note (#5562 review r1 L2) and leaves the common reach; the next tab or range change asks again. */
     if (picker === rangePicker) picker.setSampleInterval(null);
   });
 }
 
+/** The length of the range the reader holds for the server on screen, in milliseconds (the preset, or the custom range's span). */
+function heldSpanMs(nowMs = Date.now()) {
+  const custom = current.server ? customRanges.get(current.server) : null;
+  const resolved = custom ? resolveSpec(custom.spec, nowMs, browserZone()) : null;
+  return resolved && resolved.ok ? resolved.range.spanMs : pageHours * HOUR_MS;
+}
+
 /* This server's fleet card, plus the reason sentence the fleet's worst-first ranking computed for it. ONE
  * /api/fleet read serves both jobs the page has for it — the header's band and reason, and the engine the tab
  * set is chosen by — because two callers of the same endpoint on one page render is a second request nobody
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
index f9ca096339..90d0e2c353 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range-picker.js
@@ -56,6 +56,8 @@ let pickerCount = 0;
  * @param {number} [opts.reachHours] the longest range the page's reads take, in hours (default 168); longer ones are greyed out
  * @param {number|null} [opts.sampleIntervalMs] the main collector's interval; a span with fewer than 3 samples shows a note
  * @param {object[]} [opts.extraPresets] quick choices added after the shared list (a read that reaches past 30 days offers its reach)
+ * @param {(hours: number) => string} [opts.reachMessage] the reason a range past the reach is greyed out, for a page that is not "this page"
+ *   (the server page says "This tab reads up to 7 days.")
  * @param {boolean} [opts.compact] hide the detail beside the button (it moves into the tooltip)
  * @param {boolean} [opts.rollingOnly] offer only "this long back from now" (#5562 R5, the FinOps pages): no calendar periods, no
  *   custom end, whole hours, at least one hour. A range outside that is greyed out or refused with the reason, never clamped.
@@ -128,7 +130,11 @@ export function timeRangePicker(opts = {}) {
   /* Why this page cannot read the range, or null: past the reach, outside a rolling-only page's shape, or under its own floor. */
   function refusalFor(next, range) {
     const rolling = opts.rollingOnly ? rollingOnlyRefusal(next, range.spanMs, opts.minSpanMs || undefined, opts.stepMs || undefined) : null;
-    return rolling || minSpanRefusal(range.spanMs, opts.minSpanMs) || reachRefusal(range.spanMs, reach);
+    if (rolling) return rolling;
+    const tooShort = minSpanRefusal(range.spanMs, opts.minSpanMs);
+    if (tooShort) return tooShort;
+    const tooLong = reachRefusal(range.spanMs, reach);
+    return tooLong && opts.reachMessage ? opts.reachMessage(reach) : tooLong;
   }
 
   function choose(next) {

From d8b0c4e035cf1b108d053341ee9af75d599b375b Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 14:35:25 -0400
Subject: [PATCH 28/33] A calendar period at exactly its start says it has only
 just started, on the web and in the desktop picker; the two read-name scans
 skip reachReads and the interval pin follows the null guard (#5562 review r1
 finish)

---
 .../Fixtures/time-range-cases.json            | 26 ++++++++++++++++++-
 Darling/Darling.Tests/ServerPageTabsTests.cs  | 14 ++++++++--
 Darling/Darling.Tests/TimeRangeTests.cs       |  6 +++++
 Darling/Darling.Tests/WebPageRangeTests.cs    |  6 +++--
 Darling/Darling.Tests/time-range-harness.mjs  |  1 +
 .../wwwroot/js/time-range.js                  |  3 ++-
 .../TimeRange/TimeRangeSpec.cs                |  9 ++++++-
 PerformanceMonitor.Ui/TimeRangePicker.xaml.cs |  2 +-
 8 files changed, 59 insertions(+), 8 deletions(-)

diff --git a/Darling/Darling.Tests/Fixtures/time-range-cases.json b/Darling/Darling.Tests/Fixtures/time-range-cases.json
index 491bccb33d..80d8efe144 100644
--- a/Darling/Darling.Tests/Fixtures/time-range-cases.json
+++ b/Darling/Darling.Tests/Fixtures/time-range-cases.json
@@ -3,7 +3,7 @@
   "Shared cases for the time range grammar (#5562). The C# parser (PerformanceMonitor.Ui TimeRangeParser) and the web module (time-range.js) must both produce every row here.",
   "Zone ids are IANA names (America/New_York, UTC, Asia/Kolkata, Australia/Sydney): .NET resolves them through ICU and Node through Intl. Do not use Windows ids.",
   "All instants are ISO 8601 UTC with a trailing Z. 'now' is the clock the case is resolved at; nothing reads the machine's clock.",
-  "'start' and 'end' are the resolved instants (end is now for a live range). 'live' is true when the end slides with now. 'echo' is the exact label text the picker shows. 'error' is a stable code; the message text is not compared.",
+  "'start' and 'end' are the resolved instants (end is now for a live range). 'live' is true when the end slides with now. 'echo' is the exact label text the picker shows. 'error' is a stable code; the message text is not compared unless the row also carries errorMessage, the exact words both front ends must give.",
   "Typed wall times use the earliest instant for a start and the latest for an end (a repeated hour widens; a skipped time maps to the change instant). Nm/Nh/Nd are real elapsed time. Calendar periods use wall-clock midnights in the zone and weeks start Monday. 1mo is 30 real days.",
   "Echo format: '<length>  <start> - <end> (<zone>)'. Length is Nd (floored) for a day or more, else 'Hh Mm' with zero parts dropped. A bound is 'Mon D, h:mm am|pm' (English month abbreviations, lower-case am/pm), with ', YYYY' after the day when either end is not in now's year, ':ss' for typed/unix ranges when the seconds are not zero, and ' +hh:mm' appended to a bound whose wall time happens twice. Zone is 'UTC-04:00' or 'UTC-05:00 to UTC-04:00' when the ends differ."
  ],
@@ -977,6 +977,30 @@
    "echo": "2m  Oct 8, 12:00 am - Oct 8, 12:02 am (UTC-04:00)",
    "error": null
   },
+  {
+   "name": "today at exactly midnight has not started",
+   "input": "today",
+   "now": "2026-10-08T04:00:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "too_short",
+   "errorMessage": "Today has only just started. Pick another range."
+  },
+  {
+   "name": "week to date at Monday midnight has not started",
+   "input": "week to date",
+   "now": "2026-10-05T04:00:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "too_short",
+   "errorMessage": "Week to Date has only just started. Pick another range."
+  },
   {
    "name": "end before start",
    "input": "Oct 2 - Oct 1",
diff --git a/Darling/Darling.Tests/ServerPageTabsTests.cs b/Darling/Darling.Tests/ServerPageTabsTests.cs
index 247b969622..dd650d8a62 100644
--- a/Darling/Darling.Tests/ServerPageTabsTests.cs
+++ b/Darling/Darling.Tests/ServerPageTabsTests.cs
@@ -50,6 +50,16 @@ public sealed class ServerPageTabsTests
     private static string ServerTabsJs => ReadRepoFileLf(Path.Combine(
         "Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tabs.js"));
 
+    /// <summary>
+    /// <c>server-tabs.js</c> without the <c>reachReads: [...]</c> lists (#5562 M4). A tab's <c>reachReads</c> names
+    /// the windowed reads it makes so the picker can derive the tab's reach from the catalog; it does not FETCH them.
+    /// The two scans that count how often a tab fetches a read must not see those names as a second fetch. The
+    /// strip is a pattern over the list only, so a read the tab really makes still counts, and
+    /// <c>WebServerPageRangeTests</c> holds the lists themselves (every name served, every windowed read declared).
+    /// </summary>
+    private static string ServerTabsJsWithoutReachReads =>
+        Regex.Replace(ServerTabsJs, @"reachReads:\s*\[[^\]]*\]", "reachReads: []", RegexOptions.CultureInvariant);
+
     private static string ServerJs => ReadRepoFileLf(Path.Combine(
         "Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server.js"));
 
@@ -130,7 +140,7 @@ it contributes nothing to the auroraOnly set below. It is mapped anyway because
     [Fact]
     public void TheQueryStoreTopGrid_DrawsTheApproximationNote_AsAFurtherNote()
     {
-        var js = ServerTabsJs;
+        var js = ServerTabsJsWithoutReachReads;
         var at = js.IndexOf("\"get_query_store_top\",", StringComparison.Ordinal);
         Assert.True(at >= 0);
         var end = js.IndexOf("\n      ),", at, StringComparison.Ordinal);
@@ -1040,7 +1050,7 @@ public void SingleBucketSeries_RendersAsAMarker_NotTheWarmingUpStrip()
     [Fact]
     public void NoTab_FetchesTheSameReadTwice()
     {
-        var js = ServerTabsJs;
+        var js = ServerTabsJsWithoutReachReads;
 
         /* The composite -> reads map, verified against the composites themselves before it is trusted. */
         var composites = new Dictionary<string, string[]>(StringComparer.Ordinal)
diff --git a/Darling/Darling.Tests/TimeRangeTests.cs b/Darling/Darling.Tests/TimeRangeTests.cs
index 694314382f..eb77bb62ae 100644
--- a/Darling/Darling.Tests/TimeRangeTests.cs
+++ b/Darling/Darling.Tests/TimeRangeTests.cs
@@ -67,6 +67,12 @@ public void Parse_MatchesTheSharedFixture(string label, string caseJson)
             Assert.False(result.Ok, "expected an error but got " + result.Echo);
             Assert.Equal(expectedError.GetString(), result.ErrorCode);
             Assert.False(string.IsNullOrWhiteSpace(result.Error));
+            if (c.TryGetProperty("errorMessage", out var message))
+            {
+                // A row that states its words holds both front ends to them (the midnight refusal of a calendar period).
+                Assert.Equal(message.GetString(), result.Error);
+            }
+
             Assert.Equal(string.Empty, result.Echo);
             return;
         }
diff --git a/Darling/Darling.Tests/WebPageRangeTests.cs b/Darling/Darling.Tests/WebPageRangeTests.cs
index a80dd0b82d..70133a1f36 100644
--- a/Darling/Darling.Tests/WebPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebPageRangeTests.cs
@@ -151,7 +151,9 @@ public void TheServerPageGivesThePickerTheTabsActualCollectorInterval_AndNeverWi
     {
         var server = Js("pages", "server.js");
         Assert.Contains("serverCatalog(server).then((catalog) => {", server);
-        Assert.Contains("picker.setSampleInterval(collectorIntervalFromCatalog(catalog, tab.collector));", server);
+        // A tab with no collector gives the picker no interval (null: no sample note, and the range is never widened);
+        // collectorIntervalFromCatalog itself answers null for a missing collector, so the guard and the helper agree.
+        Assert.Contains("picker.setSampleInterval(tab.collector ? collectorIntervalFromCatalog(catalog, tab.collector) : null);", server);
         // The note is set before the keep-the-panels return, so a poll that keeps the grid still gets it.
         var noteCall = server.IndexOf("  applySampleNote();", StringComparison.Ordinal);
         Assert.True(noteCall >= 0, "server.js no longer calls applySampleNote().");
@@ -204,7 +206,7 @@ public void ThePureParts_RunUnderNode()
         // R9: Today two minutes after midnight is held (a calendar period is exempt from the floor); exactly midnight is refused; a typed span keeps the floor.
         var floor = r.GetProperty("calendarFloor");
         Assert.Equal(1, floor.GetProperty("twoMinutesIn").GetProperty("window").GetProperty("hours").GetInt32());
-        Assert.Contains("shortest range is 5 minutes", floor.GetProperty("atMidnight").GetProperty("error").GetString());
+        Assert.Equal("Today has only just started. Pick another range.", floor.GetProperty("atMidnight").GetProperty("error").GetString());
         Assert.Equal("too_short", floor.GetProperty("typedUnderFloor").GetString());
 
         // The per-server catalog is read once, kept for its time to live, then read again (and expires on lookup, not on a timer that holds Node open).
diff --git a/Darling/Darling.Tests/time-range-harness.mjs b/Darling/Darling.Tests/time-range-harness.mjs
index cd903b88b9..23154372b1 100644
--- a/Darling/Darling.Tests/time-range-harness.mjs
+++ b/Darling/Darling.Tests/time-range-harness.mjs
@@ -31,6 +31,7 @@ for (const c of fixture.cases) {
   if (c.error) {
     if (r.ok) problems.push("expected error " + c.error + " but got " + r.echo);
     else if (r.errorCode !== c.error) problems.push("error code " + r.errorCode + " (" + r.error + "), expected " + c.error);
+    else if (c.errorMessage && r.error !== c.errorMessage) problems.push("error message '" + r.error + "', expected '" + c.errorMessage + "'");
   } else if (!r.ok) {
     problems.push("refused with " + r.errorCode + " (" + r.error + ")");
   } else {
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
index c7cef9f860..632cfc6d15 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
@@ -439,7 +439,8 @@ export function resolveSpec(spec, nowMs, zone) {
   /* A calendar period is exempt from the 5-minute floor (#5562): "Today" at 00:02 reads 00:00 to now and the "collected every N min" note
      explains a sparse chart; no other range is ever substituted. Typed spans, "since" and custom start/end keep the floor. A period that
      has not started (zero length, exactly midnight) is still refused. */
-  if (spec.kind === "calendar" ? end <= start : end - start < MINIMUM_SPAN_MS) return fail("too_short", shortMessage(end - start));
+  if (spec.kind === "calendar" && end <= start) return fail("too_short", specName(spec) + " has only just started. Pick another range.");
+  if (spec.kind !== "calendar" && end - start < MINIMUM_SPAN_MS) return fail("too_short", shortMessage(end - start));
   return { ok: true, range: buildRange(spec, start, end, live, zone, nowMs) };
 }
 
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
index decb6c6609..7cb7703afd 100644
--- a/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
@@ -202,7 +202,14 @@ public bool TryResolve(DateTime nowUtc, TimeZoneInfo zone, out ResolvedTimeRange
         /* A calendar period is exempt from the floor (#5562, seat ruling): "Today" at 00:02 reads 00:00 to now and the "collected
            every N min" note explains a sparse chart; no other range is ever substituted. The floor applies to typed spans and
            custom start/end only. A period that has not started (zero length) is still refused. */
-        if (Kind == TimeRangeKind.Calendar ? end <= start : end - start < MinimumSpan)
+        if (Kind == TimeRangeKind.Calendar && end <= start)
+        {
+            /* Zero length: say that the period has not begun, not that 5 minutes is the floor (the web words it the same way). */
+            error = new TimeRangeError("too_short", Name + " has only just started. Pick another range.");
+            return false;
+        }
+
+        if (Kind != TimeRangeKind.Calendar && end - start < MinimumSpan)
         {
             error = new TimeRangeError("too_short", ShortMessage(end - start));
             return false;
diff --git a/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs b/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
index 85b3aefbd4..bc247cc55b 100644
--- a/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
+++ b/PerformanceMonitor.Ui/TimeRangePicker.xaml.cs
@@ -370,7 +370,7 @@ private void RefreshPeriodLengths()
             var text = TimeRangePresets.CurrentLength(spec, now, zone);
             length.Text = text ?? string.Empty;
             button.IsEnabled = text is not null;
-            button.ToolTip = text is null ? spec.Name + " has only just started; the shortest range is 5 minutes." : spec.Name;
+            button.ToolTip = text is null ? spec.Name + " has only just started. Pick another range." : spec.Name;
         }
     }
 

From 0be679e1ebc7cb3653da16f248d22ac35300ae59 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 14:41:06 -0400
Subject: [PATCH 29/33] Server page title pin follows the reach slot in the
 page's mount (#5562)

---
 Darling/Darling.Tests/ServerPageTitlePinTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Darling/Darling.Tests/ServerPageTitlePinTests.cs b/Darling/Darling.Tests/ServerPageTitlePinTests.cs
index a9d4a52dd5..5af915d874 100644
--- a/Darling/Darling.Tests/ServerPageTitlePinTests.cs
+++ b/Darling/Darling.Tests/ServerPageTitlePinTests.cs
@@ -82,7 +82,7 @@ public void TheRouteKey_StaysTheIdentity_OnlyTheHeadingChanges()
 
         Assert.Contains("const matches = (c) => c.server_name === server || c.display_name === server;", js, StringComparison.Ordinal);
         Assert.Contains("current = { server, tab: null };", js, StringComparison.Ordinal);
-        Assert.Contains("mount(main, [head, whySlot, tabsSlot, gridNode]);", js, StringComparison.Ordinal);
+        Assert.Contains("mount(main, [head, whySlot, tabsSlot, reachSlot, gridNode]);", js, StringComparison.Ordinal);
         Assert.DoesNotContain("server = card.display_name", js, StringComparison.Ordinal);
         Assert.DoesNotContain("current = { server: card.display_name", js, StringComparison.Ordinal);
     }

From b09bb0d6dfc0ce7288cba6b392b7d10db2c4bbdd Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 15:15:03 -0400
Subject: [PATCH 30/33] Time range picker review round 2: alert times parsed as
 UTC, future-start ranges refused, one redraw per catalog wait, Storage Growth
 90 days, midnight comment (#5562)

---
 .../AlertHistoryRangePageTests.cs             | 21 ++++++++--
 ...FinOpsStorageGrowthWindowBehaviourTests.cs |  2 +-
 .../Fixtures/time-range-cases.json            | 12 ++++++
 .../Darling.Tests/WebServerPageRangeTests.cs  | 30 ++++++++++++++
 Darling/Darling.Tests/WebTimeRangeTests.cs    |  6 +++
 .../alert-history-range-harness.mjs           | 10 ++++-
 .../time-range-picker-harness.mjs             |  8 ++++
 .../web-kept-history-harness.mjs              | 41 +++++++++++++++++++
 .../wwwroot/js/pages/alerts.js                | 10 +++--
 .../wwwroot/js/pages/finops/storage-growth.js |  2 +
 .../wwwroot/js/pages/finops/window.js         |  3 ++
 .../wwwroot/js/pages/server.js                | 16 ++++++--
 .../wwwroot/js/time-range.js                  |  6 ++-
 .../TimeRange/TimeRangeParser.cs              |  2 +-
 .../TimeRange/TimeRangePresets.cs             |  2 +-
 .../TimeRange/TimeRangeSpec.cs                |  8 ++++
 16 files changed, 161 insertions(+), 18 deletions(-)

diff --git a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
index 17c9ecfb76..f1d05c2328 100644
--- a/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
+++ b/Darling/Darling.Tests/AlertHistoryRangePageTests.cs
@@ -73,12 +73,17 @@ public void TheChoicesLiveAtModuleScopeAndTheDismissRouteIsNotTheDesktopOne()
         Assert.DoesNotContain("/api/alerts/dismiss", page);
     }
 
-    private static JsonElement Run(string scenario)
+    private static JsonElement Run(string scenario, string? timeZone = null)
     {
         var psi = new ProcessStartInfo("node") { RedirectStandardOutput = true, RedirectStandardError = true, UseShellExecute = false };
         psi.ArgumentList.Add(PathTo("Darling", "Darling.Tests", "alert-history-range-harness.mjs"));
         psi.ArgumentList.Add(PathTo("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js"));
         psi.ArgumentList.Add(scenario);
+        if (timeZone is not null)
+        {
+            psi.ArgumentList.Add(timeZone);
+        }
+
         Process proc;
         try
         {
@@ -219,10 +224,18 @@ public void ANewWindowReconcilesInPlace_RowsLeaveAndNewOnesLandInOrder()
         Assert.Equal("High CPU 3", string.Join(",", r.GetProperty("shrunk").EnumerateArray().Select(e => e.GetString())));
     }
 
-    [Fact]
-    public void ARangeShorterThanTheWholeHoursItFetches_ListsOnlyTheAlertsInsideIt()
+    // Review r2 H1: alert_time is naive UTC with no zone suffix, which the browser reads as LOCAL time unless the page parses it as UTC. The
+    // harness rows carry the server's real shape, and the same scenario runs in zones that are not UTC (and in UTC) because a UTC-only run
+    // passes the old Date.parse code. The offset check proves Node honoured the zone, so the test cannot pass by running in UTC every time.
+    [Theory]
+    [InlineData("UTC", 0)]
+    [InlineData("Europe/Berlin", -1)]
+    [InlineData("America/New_York", 1)]
+    [InlineData("Asia/Tokyo", -1)]
+    public void ARangeShorterThanTheWholeHoursItFetches_ListsOnlyTheAlertsInsideIt(string zone, int offsetSign)
     {
-        var r = Run("trim");
+        var r = Run("trim", zone);
+        Assert.Equal(offsetSign, Math.Sign(r.GetProperty("tzOffsetMinutes").GetInt32()));
         string[] Names(string key) => r.GetProperty(key).EnumerateArray().Select(e => e.GetString()!).ToArray();
         Assert.Equal(new[] { "High CPU 0", "High CPU 19", "High CPU 89" }, Names("day"));
         Assert.Equal(new[] { "High CPU 0" }, Names("fiveMinutes"));
diff --git a/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs b/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
index 39c19a59e2..05ed63e65c 100644
--- a/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
+++ b/Darling/Darling.Tests/FinOpsStorageGrowthWindowBehaviourTests.cs
@@ -85,7 +85,7 @@ public void TheObjectsLevelDefaultsToThirtyDays_AndEachPickSendsDaysTimes24()
         var objects = run.GetProperty("objects");
         Assert.Equal(new[] { "720" }, Hours(objects));
         // #5562 R5: the Compact rolling-only picker, whole days, reach 2160 hours for this view (not the catalog entry's 168).
-        Assert.Equal("Past week,Past 30 days", string.Join(",", objects.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
+        Assert.Equal("Past week,Past 30 days,Past 90 days", string.Join(",", objects.GetProperty("options").EnumerateArray().Select(e => e.GetString())));
         var refused = objects.GetProperty("refused");
         Assert.Equal("This page reads whole days back from now, such as 7d or 30d.", refused.GetProperty("hours").GetString());
         Assert.Equal("This page reads a length back from now, so pick a rolling length such as 24h or 7d.", refused.GetProperty("calendar").GetString());
diff --git a/Darling/Darling.Tests/Fixtures/time-range-cases.json b/Darling/Darling.Tests/Fixtures/time-range-cases.json
index 80d8efe144..b0376869c7 100644
--- a/Darling/Darling.Tests/Fixtures/time-range-cases.json
+++ b/Darling/Darling.Tests/Fixtures/time-range-cases.json
@@ -1122,6 +1122,18 @@
    "echo": null,
    "error": "bad_range"
   },
+  {
+   "name": "a fixed range that starts in the future is refused (review r2 M1)",
+   "input": "Dec 25 2030 - Dec 26 2030",
+   "now": "2026-10-08T11:01:00Z",
+   "zone": "America/New_York",
+   "start": null,
+   "end": null,
+   "live": null,
+   "echo": null,
+   "error": "range_not_started",
+   "errorMessage": "That range has not started yet."
+  },
   {
    "name": "too far back",
    "input": "99999999 days",
diff --git a/Darling/Darling.Tests/WebServerPageRangeTests.cs b/Darling/Darling.Tests/WebServerPageRangeTests.cs
index 37584d7547..4d7b045ac9 100644
--- a/Darling/Darling.Tests/WebServerPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebServerPageRangeTests.cs
@@ -308,6 +308,36 @@ public void AWideRange_OnAServerWhoseCatalogIsNotRead_WaitsForTheCatalog_AndRead
         Assert.Empty(Strings(r, "errors"));
     }
 
+    /// <summary>Review r2 M1: the server page's hold refuses a fixed range that starts in the future, in the picker's words, and the range
+    /// it had is still the range it reads (before this, the past hour was read under the future range's label).</summary>
+    [Fact]
+    public void AFixedRangeThatStartsInTheFuture_IsRefusedByTheHold_AndTheHeldRangeStays()
+    {
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("tabReachHoldFutureStart", out var r, CatalogJson())) return;
+
+        var found = r.GetProperty("found");
+        Assert.Equal("That range has not started yet.", found.GetProperty("refused").GetString());
+        Assert.Equal(found.GetProperty("beforeHours").GetInt32(), found.GetProperty("afterHours").GetInt32());
+        Assert.False(found.GetProperty("custom").GetBoolean());
+    }
+
+    /// <summary>Review r2 L2: while the catalog is pending, a second render of the same server (a range change or the 60 second refresh
+    /// both redraw the panels) adds no second wait. Two waits ran two redraws when the catalog arrived, so every panel read was sent twice.</summary>
+    [Fact]
+    public void ARedrawDuringTheCatalogWait_ReadsEachPanelOnce()
+    {
+        if (!WebRangeKeptHistoryBehaviourTests.TryRun("tabReachWaitsRedrawn", out var r, CatalogJson())) return;
+
+        var found = r.GetProperty("found");
+        Assert.Equal(0, found.GetProperty("readsBeforeRelease").GetInt32());
+        // One batch of panel builds when the catalog arrives, not one per redraw that hit the wait.
+        Assert.Equal(1, found.GetProperty("builds").GetInt32());
+        var reads = Strings(found, "reads");
+        Assert.NotEmpty(reads);
+        Assert.Equal(reads.Length, found.GetProperty("distinct").GetInt32());
+        Assert.Empty(Strings(r, "errors"));
+    }
+
     /// <summary>A custom start and end maps to the reads' window: <c>as_of</c> is the end and <c>hours</c> is the span rounded
     /// UP to whole hours, so the fetch starts at or before the picked start. A span under an hour, a reversed pair, a future
     /// end and a span wider than the widest preset are refused; an end at "now" is live and names no <c>as_of</c>.</summary>
diff --git a/Darling/Darling.Tests/WebTimeRangeTests.cs b/Darling/Darling.Tests/WebTimeRangeTests.cs
index d97e831fac..7b16c4402a 100644
--- a/Darling/Darling.Tests/WebTimeRangeTests.cs
+++ b/Darling/Darling.Tests/WebTimeRangeTests.cs
@@ -228,6 +228,12 @@ public void ThePresetsAndThePick_ApplyHoldAndPreview()
         Assert.Equal(3, futureEnd.GetProperty("future").GetProperty("hours").GetInt32());
         Assert.False(futureEnd.GetProperty("past").GetProperty("live").GetBoolean());
         Assert.NotEqual(JsonValueKind.Null, futureEnd.GetProperty("past").GetProperty("asOf").ValueKind);
+
+        // Review r2 M1: a fixed range that starts in the future is refused with its reason, Apply stays off and nothing is held.
+        var futureStart = r.GetProperty("futureStart");
+        Assert.Equal("That range has not started yet.", futureStart.GetProperty("preview").GetString());
+        Assert.True(futureStart.GetProperty("applyDisabled").GetBoolean());
+        Assert.Equal(0, futureStart.GetProperty("changes").GetInt32());
     }
 
     /// <summary>Compact moves the detail into the tooltip; the sample-interval note shows when the span holds fewer than three samples;
diff --git a/Darling/Darling.Tests/alert-history-range-harness.mjs b/Darling/Darling.Tests/alert-history-range-harness.mjs
index c23c01363a..628e8c76d1 100644
--- a/Darling/Darling.Tests/alert-history-range-harness.mjs
+++ b/Darling/Darling.Tests/alert-history-range-harness.mjs
@@ -1,7 +1,7 @@
 /* Runs the shipped Alert History page (wwwroot/js/pages/alerts.js) with the real shared renderer (panels.js, util.js,
    mute-context.js) on a small fake DOM and a recording fetch, and prints as one line of JSON what the page asked for
    and drew. AlertHistoryRangeBehaviourTests starts it as
-       node alert-history-range-harness.mjs <path to wwwroot/js> <scenario>
+       node alert-history-range-harness.mjs <path to wwwroot/js> <scenario> [IANA time zone]
    Only the DOM, fetch and charts.js are stand-ins. */
 import fs from "node:fs";
 import os from "node:os";
@@ -44,6 +44,9 @@ globalThis.location = { hash: "#/alerts" };
 
 const jsDir = process.argv[2];
 const scenario = process.argv[3];
+// Node on Windows ignores a TZ variable set before it starts, but honours one set on process.env from inside, so the zone is an argument
+// (#5570 r2 H1): the page's time parsing must give the same answer in every browser zone, and a harness stuck in UTC cannot show that.
+if (process.argv[4]) process.env.TZ = process.argv[4];
 
 const urls = [];
 let alertsReply = { alerts: [], truncated: false };
@@ -62,7 +65,9 @@ const readsOf = () => urls.filter((u) => u.includes("/get_alert_history")).map((
 
 const T0 = Date.now();
 const row = (i, over = {}) => ({
-  alert_time: new Date(T0 - 60000 - i * 60000).toISOString(),
+  // The server's shape: alert_time is r.AlertTime.ToString("o") of a naive-UTC timestamp, so seven fraction digits and NO zone suffix
+  // (#5570 r2 H1). toISOString() would add a Z, which hides a reader that parses the text as local time.
+  alert_time: new Date(T0 - 60000 - i * 60000).toISOString().replace("Z", "0000"),
   server_id: 1, server_name: "srv-a", stored_server_name: "srv-a", metric_name: "High CPU " + i,
   current_value: 90, threshold_value: 80, severity: "warning", severity_source: "fired", dismissed: false, ...over,
 });
@@ -192,6 +197,7 @@ try {
       pickRange(main, "Time range", "5m"); await settle(); out.fiveMinutes = metrics(main);
       pickRange(main, "Time range", "30m"); await settle(); out.thirtyMinutes = metrics(main);
       pickRange(main, "Time range", "4h"); await settle(); out.fourHours = metrics(main);
+      out.tzOffsetMinutes = new Date().getTimezoneOffset();
     },
     async mute() {
       alertsReply = { alerts: [row(1)], truncated: false };
diff --git a/Darling/Darling.Tests/time-range-picker-harness.mjs b/Darling/Darling.Tests/time-range-picker-harness.mjs
index 1b0c294815..1c2f306fa7 100644
--- a/Darling/Darling.Tests/time-range-picker-harness.mjs
+++ b/Darling/Darling.Tests/time-range-picker-harness.mjs
@@ -278,4 +278,12 @@ const found = {};
   found.futureEnd = { future: p.window(), past: past.p.window() };
 }
 
+/* 14. Review r2 M1: a fixed range that starts in the future is refused with its reason, and Apply stays off; nothing is held or sent. */
+{
+  const { root, button, changes } = make();
+  fire(button, "click");
+  const typed = typeInto(root, "Dec 25 2030 - Dec 26 2030");
+  found.futureStart = { ...typed, changes: changes.length };
+}
+
 console.log(JSON.stringify(found));
diff --git a/Darling/Darling.Tests/web-kept-history-harness.mjs b/Darling/Darling.Tests/web-kept-history-harness.mjs
index 15e5307bdf..eda3ad58c0 100644
--- a/Darling/Darling.Tests/web-kept-history-harness.mjs
+++ b/Darling/Darling.Tests/web-kept-history-harness.mjs
@@ -688,6 +688,47 @@ Object.assign(scenarios, {
     found = { fetches: after, firstRead: after.findIndex((f) => f.startsWith("/api/read/")), catalog: after.findIndex((f) => f.startsWith("/api/catalog")) };
     return [holder];
   },
+  // Review r2 M1: a fixed range that starts in the future is refused by the server page's hold, and the range it had stays.
+  tabReachHoldFutureStart: async () => {
+    tabReachAnswers();
+    const holder = await tabPage("SRV1", "io");
+    const before = modules.server.rangeContext(NOW);
+    const refused = modules.server.holdSpec("SRV1", modules.timeRange.fixedSpec(NOW + HOURS, NOW + 3 * HOURS), NOW);
+    const after = modules.server.rangeContext(NOW);
+    found = { refused, beforeHours: before.hours, afterHours: after.hours, custom: after.custom === true };
+    return [holder];
+  },
+  // Review r2 L2: while the catalog is pending, another redraw of the same server (a range change or the 60 second refresh both call
+  // redrawPanels) must not add a second wait, or two redraws run when the catalog arrives and the panels' reads go out twice. The catalog
+  // answer is held back until the second render has happened. The batches are counted at the tab's build(): the page joins identical reads
+  // that are in flight together, so two batches can still show as one set of URLs, but each batch is a full rebuild of the panels.
+  tabReachWaitsRedrawn: async () => {
+    tabReachAnswers();
+    await tabPage("SRV1", "io");
+    modules.server.holdSpec("SRV1", modules.timeRange.relativeSpec(720 * HOURS), NOW);
+    const ioTab = modules.tabs.SERVER_TABS.find((t) => t.id === "io");
+    const realBuild = ioTab.build;
+    let builds = 0;
+    ioTab.build = (...args) => { builds++; return realBuild.apply(ioTab, args); };
+    const realFetch = globalThis.fetch;
+    let release;
+    const gate = new Promise((r) => { release = r; });
+    globalThis.fetch = async (url, init) => {
+      if (String(url).startsWith("/api/catalog")) await gate;
+      return realFetch(url, init);
+    };
+    const before = fetches.length;
+    const holder = await tabPage("SRV2", "io");
+    const again = await tabPage("SRV2", "io");
+    const readsBeforeRelease = fetches.slice(before).filter((f) => f.startsWith("/api/read/")).length;
+    release();
+    await settleFast();
+    globalThis.fetch = realFetch;
+    ioTab.build = realBuild;
+    const reads = fetches.slice(before).filter((f) => f.startsWith("/api/read/"));
+    found = { readsBeforeRelease, builds, reads, distinct: new Set(reads).size };
+    return [holder, again];
+  },
 });
 
 const chosen = scenarios[scenario];
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
index 44a21b2dba..336f62af11 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/alerts.js
@@ -24,7 +24,7 @@
  */
 
 import { el, mount, readTool, apiSend, buildQuery, loadingStrip, errorStrip, emptyStrip, noticeStrip, disclosure,
-         ALERT_STATE_LABELS, alertDeliveryState } from "../util.js";
+         ALERT_STATE_LABELS, alertDeliveryState, parseUtc } from "../util.js";
 import { VIZ, reapplyGridSort, gridRowOf } from "../panels.js";
 import { copyText } from "../grid-tools.js";
 import { pageRangePicker, windowResultOfSpec } from "../page-range.js";
@@ -440,11 +440,13 @@ function readRequest() {
 }
 
 /* Keeps the alerts at or after the range start. The newest-first reply and the row cap mean the cut cannot hide an in-range row (the
- * rows it drops are the oldest), the same argument job-history.js makes for its runs. An unreadable time is kept. */
+ * rows it drops are the oldest), the same argument job-history.js makes for its runs. An unreadable time is kept.
+ * alert_time is the store's naive UTC with no zone suffix, and Date.parse would read that as the browser's LOCAL time, shifting every
+ * alert by the browser's offset, so parseUtc (util.js) reads it as UTC (#5570 review round 2, H1). */
 export function trimAlertsToStart(alerts, startMs) {
   return alerts.filter((a) => {
-    const t = Date.parse(a && a.alert_time);
-    return Number.isNaN(t) || t >= startMs;
+    const d = parseUtc(a && a.alert_time);
+    return d === null || d.getTime() >= startMs;
   });
 }
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
index 8e90d8d9c6..175285a9b7 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/storage-growth.js
@@ -195,6 +195,8 @@ export const tab = {
       return finopsWindowControl({
         hours: state.days * 24,
         view: "storage_growth",
+        /* The page always offered 7 / 30 / 90 days as one click each; the view's reach is the 90 (#5562 review r2 L3). */
+        offerReach: true,
         /* The server reads hours_back = 24 as its 30-day default and refuses 2 to 6 days (DarlingMcpFinOpsTools.StorageGrowthWindowDaysFor), so the
            shortest length the picker offers is a week (#5562 review r1 H1). */
         minSpanMs: 7 * DAY_MS,
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
index fca7537238..184730b886 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/finops/window.js
@@ -26,6 +26,8 @@ const HOUR_MS = 3600000;
  * @param {number} [opts.minSpanMs] a floor above one hour (a daily read)
  * @param {number} [opts.stepMs] the unit a length must be a whole number of (default one hour)
  * @param {string} [opts.label] the control's label (default "Window")
+ * @param {boolean} [opts.offerReach] add the view's reach as the longest quick choice when it is longer than the shared 30 days
+ *   (Storage Growth's 90, which the page always offered as one click, #5562 review r2 L3)
  * @returns {{ node: HTMLElement, picker: object, hours: () => number }}
  */
 export function finopsWindowControl(opts) {
@@ -35,6 +37,7 @@ export function finopsWindowControl(opts) {
     spec: relativeSpec(opts.hours * HOUR_MS),
     label,
     compact: true,
+    offerReach: opts.offerReach,
     rollingOnly: true,
     minSpanMs: opts.minSpanMs || ROLLING_ONLY_MIN_SPAN_MS,
     stepMs: opts.stepMs,
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
index 06882cda3c..505b22125d 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server.js
@@ -80,6 +80,9 @@ function rangeOption(hours) {
 const catalogsRead = new Map();
 /* Servers whose catalog could not be read when a wide range waited for it: they read at the common reach, and do not wait again. */
 const catalogGaveUp = new Set();
+/* The servers whose catalog is being read for the panels' wait below: one wait and one redraw per server, whatever redraws meanwhile
+   (#5562 review r2 L2). */
+const catalogWaits = new Set();
 
 /** How far back a tab's reads all reach, in hours (the smallest catalog `max_hours` among its `reachReads`). */
 function tabReach(tab = current.tab, server = current.server) {
@@ -195,11 +198,11 @@ export function rangeContext(nowMs = Date.now()) {
          The range stays held (the next tab may take all of it), and reachNoteText says what happened (#5562 review r1 M4). */
       const cut = tabReachRefusal(resolved.range.spanMs, reach) != null;
       const range = cut ? { ...resolved.range, startMs: resolved.range.endMs - reach * HOUR_MS, spanMs: reach * HOUR_MS } : resolved.range;
-      const w = readWindow(range);
+      const w = readWindow(range, nowMs);
       setActiveRange({ server: current.server, hours: w.hours, startMs: range.startMs, endMs: range.endMs, asOf: w.asOf });
       /* Totals and rankings are read over whole hours back from the end, so they can begin earlier than the picked start:
          when the span is not a whole number of hours the label says where they begin. */
-      const aggregateFrom = range.endMs - w.hours * HOUR_MS;
+      const aggregateFrom = w.endMs - w.hours * HOUR_MS;
       const rounded = aggregateFrom < range.startMs ? "; totals and rankings aggregate from " + localTime(new Date(aggregateFrom).toISOString()) : "";
       const times = localTime(new Date(range.startMs).toISOString()) + " to " + (range.live ? "now" : localTime(new Date(range.endMs).toISOString()));
       const picked = custom.spec.kind === "relative" || custom.spec.kind === "calendar" ? specName(custom.spec).toLowerCase() : "custom";
@@ -383,13 +386,18 @@ function redrawPanels() {
      last 7 days of it), so the panels wait for the catalog rather than read twice. A held range within the common reach reads now. */
   if (!catalogsRead.has(current.server) && !catalogGaveUp.has(current.server) && heldSpanMs() > DEFAULT_REACH_HOURS * HOUR_MS) {
     const server = current.server;
-    const tab = current.tab;
     if (panelAbort) panelAbort.abort();
     mount(gridNode, [loadingStrip()]);
+    /* A range change or the 60 second refresh during the wait lands here again: it keeps the loading strip and adds no second wait, or
+       two redraws would run when the catalog arrives and send the panels' reads twice (#5562 review r2 L2). The one redraw reads the
+       tab and range held at that moment, so a change made during the wait is read once. */
+    if (catalogWaits.has(server)) return;
+    catalogWaits.add(server);
     serverCatalog(server).catch(() => null).then((catalog) => {
+      catalogWaits.delete(server);
       if (catalog) catalogsRead.set(server, catalog);
       else catalogGaveUp.add(server);
-      if (server === current.server && tab === current.tab) redrawPanels();
+      if (server === current.server) redrawPanels();
     });
     return;
   }
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
index 632cfc6d15..22ee85e91d 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/time-range.js
@@ -436,6 +436,10 @@ export function resolveSpec(spec, nowMs, zone) {
       ? fail("start_in_future", "That start has not happened yet.")
       : fail("end_before_start", "The end is before the start.");
   }
+  /* A fixed range that starts in the future (typed with a year ahead, or picked in the date boxes) is refused (#5562 review r2 M1): a
+     read cannot answer a window that has not begun, and the page would otherwise read the past hour under the future range's label.
+     Here, in the one resolver, so the picker's preview and Apply, the server page's hold and the shared fixture all see the same refusal. */
+  if (spec.kind === "fixed" && start > nowMs) return fail("range_not_started", "That range has not started yet.");
   /* A calendar period is exempt from the 5-minute floor (#5562): "Today" at 00:02 reads 00:00 to now and the "collected every N min" note
      explains a sparse chart; no other range is ever substituted. Typed spans, "since" and custom start/end keep the floor. A period that
      has not started (zero length, exactly midnight) is still refused. */
@@ -780,7 +784,7 @@ function parseSpec(text, nowMs, zone) {
 /**
  * Reads a line of text as a range at `nowMs` in `zone`. Returns `{ ok, range, spec, echo, error, errorCode }`: `echo` is the
  * range's one-line label (empty on an error), `error` the plain reason and `errorCode` the stable code (empty, unrecognized,
- * bad_date, bad_time, bad_range, needs_end, too_short, end_before_start, start_in_future, too_far_back).
+ * bad_date, bad_time, bad_range, needs_end, too_short, end_before_start, start_in_future, range_not_started, too_far_back).
  */
 export function parseRange(text, nowMs, zone) {
   const refused = (code, message) => ({ ok: false, range: null, spec: null, echo: "", error: message, errorCode: code });
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs
index ba14f26719..365350a289 100644
--- a/PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangeParser.cs
@@ -38,7 +38,7 @@ internal TimeRangeParseResult(string code, string message)
     /// <summary>The plain reason the text was refused, or <c>null</c>.</summary>
     public string? Error { get; }
 
-    /// <summary>A stable code for the refusal: empty, unrecognized, bad_date, bad_time, bad_range, needs_end, too_short, end_before_start, start_in_future, too_far_back. <c>null</c> on success.</summary>
+    /// <summary>A stable code for the refusal: empty, unrecognized, bad_date, bad_time, bad_range, needs_end, too_short, end_before_start, start_in_future, range_not_started, too_far_back. <c>null</c> on success.</summary>
     public string? ErrorCode { get; }
 
     /// <summary>The named range, or <c>null</c> on an error.</summary>
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
index 301496937b..164abcd7bc 100644
--- a/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangePresets.cs
@@ -67,7 +67,7 @@ public static TimeRangeSpec ForBroadcast(TimeRangeSpec spec, DateTime nowUtc, Ti
         return range.IsLive ? TimeRangeSpec.SinceInstant(range.StartUtc) : TimeRangeSpec.FixedRange(range.StartUtc, range.EndUtc);
     }
 
-    /// <summary>The length of a calendar period at <paramref name="nowUtc"/> in <paramref name="zone"/> ("3d", "7h 1m"), or <c>null</c> when the period is shorter than the minimum right now (Today just after midnight).</summary>
+    /// <summary>The length of a calendar period at <paramref name="nowUtc"/> in <paramref name="zone"/> ("3d", "7h 1m"), or <c>null</c> when the period cannot be used right now: only at zero length (exactly midnight for Today), because a calendar period is exempt from the 5-minute floor (#5562).</summary>
     public static string? CurrentLength(TimeRangeSpec spec, DateTime nowUtc, TimeZoneInfo zone)
         => spec.TryResolve(nowUtc, zone, out var range, out _) ? range!.Length : null;
 
diff --git a/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
index 7cb7703afd..a918d9dc09 100644
--- a/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
+++ b/PerformanceMonitor.Ui/TimeRange/TimeRangeSpec.cs
@@ -199,6 +199,14 @@ public bool TryResolve(DateTime nowUtc, TimeZoneInfo zone, out ResolvedTimeRange
             return false;
         }
 
+        /* A fixed range that starts in the future is refused (#5562 review r2 M1), in the same words as the web module: nothing has been
+           collected for a window that has not begun, and a host that read it would show an empty chart under a future label. */
+        if (Kind == TimeRangeKind.Fixed && start > now)
+        {
+            error = new TimeRangeError("range_not_started", "That range has not started yet.");
+            return false;
+        }
+
         /* A calendar period is exempt from the floor (#5562, seat ruling): "Today" at 00:02 reads 00:00 to now and the "collected
            every N min" note explains a sparse chart; no other range is ever substituted. The floor applies to typed spans and
            custom start/end only. A period that has not started (zero length) is still refused. */

From a02545a9bc9bda1c80f9162fd9e53ad47d75d29b Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 15:23:59 -0400
Subject: [PATCH 31/33] STA test helpers take the WPF STA gate (#5559 census)
 (#5562)

---
 Darling/Darling.Tests/TimeRangePickerControlTests.cs | 1 +
 Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs  | 1 +
 2 files changed, 2 insertions(+)

diff --git a/Darling/Darling.Tests/TimeRangePickerControlTests.cs b/Darling/Darling.Tests/TimeRangePickerControlTests.cs
index d08cc05168..bb2efac59d 100644
--- a/Darling/Darling.Tests/TimeRangePickerControlTests.cs
+++ b/Darling/Darling.Tests/TimeRangePickerControlTests.cs
@@ -201,6 +201,7 @@ public void OpeningThePopup_ThemesTheCalendarFromTheHostBrushes_AndAPickedRangeF
     private static void OnStaThread(Action body)
     {
         Exception? error = null;
+        using var staGate = WpfStaGate.Enter();
         var thread = new Thread(() =>
         {
             try { body(); }
diff --git a/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs b/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
index f9f02aeb2f..5105729909 100644
--- a/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
+++ b/Darling/Darling.Tests/ViewerTimeRangeGapFixTests.cs
@@ -354,6 +354,7 @@ private static async Task CleanupAsync(NpgsqlConnection connection, Cancellation
     private static void OnStaThread(Action body)
     {
         Exception? error = null;
+        using var staGate = WpfStaGate.Enter();
         var thread = new Thread(() =>
         {
             try { body(); }

From 501bbed4381c9f47addd62f829c42f6d0856bb42 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 16:15:34 -0400
Subject: [PATCH 32/33] Server page reach lists move to their own module and
 MCP reach text moves behind the guide marker (#5562)

---
 Darling/Darling.Tests/ServerPageTabsTests.cs  |  14 +-
 Darling/Darling.Tests/WebPageRangeTests.cs    |   7 +-
 Darling/Darling.Tests/WebReadReachTests.cs    |  35 +++-
 .../Darling.Tests/WebServerPageRangeTests.cs  |  25 +--
 .../Mcp/DarlingMcpAlertTools.cs               |   4 +-
 .../Mcp/DarlingMcpBlockingTools.cs            |   6 +-
 .../Mcp/DarlingMcpDataTools.cs                |   6 +-
 .../Mcp/DarlingMcpPgCpuUtilizationTools.cs    |   4 +-
 .../Mcp/DarlingMcpPgTrendTools.cs             |   8 +-
 .../Mcp/DarlingMcpTrendTools.cs               |  16 +-
 .../wwwroot/js/pages/server-tab-reach.js      | 151 ++++++++++++++++++
 .../wwwroot/js/pages/server-tabs.js           |  85 +---------
 12 files changed, 230 insertions(+), 131 deletions(-)
 create mode 100644 Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tab-reach.js

diff --git a/Darling/Darling.Tests/ServerPageTabsTests.cs b/Darling/Darling.Tests/ServerPageTabsTests.cs
index 7e1d91e6d8..01f75b2ea5 100644
--- a/Darling/Darling.Tests/ServerPageTabsTests.cs
+++ b/Darling/Darling.Tests/ServerPageTabsTests.cs
@@ -50,16 +50,6 @@ public sealed class ServerPageTabsTests
     private static string ServerTabsJs => ReadRepoFileLf(Path.Combine(
         "Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tabs.js"));
 
-    /// <summary>
-    /// <c>server-tabs.js</c> without the <c>reachReads: [...]</c> lists (#5562 M4). A tab's <c>reachReads</c> names
-    /// the windowed reads it makes so the picker can derive the tab's reach from the catalog; it does not FETCH them.
-    /// The two scans that count how often a tab fetches a read must not see those names as a second fetch. The
-    /// strip is a pattern over the list only, so a read the tab really makes still counts, and
-    /// <c>WebServerPageRangeTests</c> holds the lists themselves (every name served, every windowed read declared).
-    /// </summary>
-    private static string ServerTabsJsWithoutReachReads =>
-        Regex.Replace(ServerTabsJs, @"reachReads:\s*\[[^\]]*\]", "reachReads: []", RegexOptions.CultureInvariant);
-
     private static string ServerJs => ReadRepoFileLf(Path.Combine(
         "Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server.js"));
 
@@ -140,7 +130,7 @@ it contributes nothing to the auroraOnly set below. It is mapped anyway because
     [Fact]
     public void TheQueryStoreTopGrid_DrawsTheApproximationNote_AsAFurtherNote()
     {
-        var js = ServerTabsJsWithoutReachReads;
+        var js = ServerTabsJs;
         var at = js.IndexOf("\"get_query_store_top\",", StringComparison.Ordinal);
         Assert.True(at >= 0);
         var end = js.IndexOf("\n      ),", at, StringComparison.Ordinal);
@@ -1050,7 +1040,7 @@ public void SingleBucketSeries_RendersAsAMarker_NotTheWarmingUpStrip()
     [Fact]
     public void NoTab_FetchesTheSameReadTwice()
     {
-        var js = ServerTabsJsWithoutReachReads;
+        var js = ServerTabsJs;
 
         /* The composite -> reads map, verified against the composites themselves before it is trusted. */
         var composites = new Dictionary<string, string[]>(StringComparer.Ordinal)
diff --git a/Darling/Darling.Tests/WebPageRangeTests.cs b/Darling/Darling.Tests/WebPageRangeTests.cs
index 70133a1f36..dafd287fb5 100644
--- a/Darling/Darling.Tests/WebPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebPageRangeTests.cs
@@ -132,8 +132,13 @@ public void SweepsAndJobHistorySendTheEndOfAFinishedRange()
     public void EveryServerTabThatDeclaresACollectorNamesARealOne_AndTheViewerAgreesOnTheSharedTabs()
     {
         var tabs = Js("pages", "server-tabs.js");
-        var declared = Regex.Matches(tabs, "(?m)^    id: \"([a-z-]+)\",\n    label: \"([^\"]+)\",\n    collector: \"([a-z_]+)\",").Select(m => (m.Groups[2].Value, m.Groups[3].Value)).ToList();
+        /* A tab's collector is declared in server-tab-reach.js (#5562 r3), by tab id, in registry order: the seven SQL Server tabs, then the
+           two PostgreSQL ones. The label is the tab's own, from the SQL Server registry's first tab of that id. */
+        var reach = Js("pages", "server-tab-reach.js");
+        var declared = Regex.Matches(reach, "(?m)^  ([a-z-]+): \\{\n    collector: \"([a-z_]+)\",")
+            .Select(m => (Regex.Match(tabs, "(?m)^    id: \"" + m.Groups[1].Value + "\",\n    label: \"([^\"]+)\",").Groups[1].Value, m.Groups[2].Value)).ToList();
         Assert.Equal(9, declared.Count);
+        Assert.All(declared, d => Assert.NotEqual(string.Empty, d.Item1));
 
         foreach (var (_, collector) in declared)
             Assert.True(CollectorScheduleDefaults.All.ContainsKey(collector), collector + " is not a collector the schedule knows");
diff --git a/Darling/Darling.Tests/WebReadReachTests.cs b/Darling/Darling.Tests/WebReadReachTests.cs
index 973d999dfa..c0bb93885a 100644
--- a/Darling/Darling.Tests/WebReadReachTests.cs
+++ b/Darling/Darling.Tests/WebReadReachTests.cs
@@ -145,12 +145,16 @@ public void NoRawTierTableRead_ReachesPastTheTimescaleRawRetention()
     }
 
     /// <summary>
-    /// Review r1 M6: the <c>hours_back</c> description of every MCP tool carries the number its <see cref="WebReadReach"/> row
-    /// holds, so raising or lowering a row cannot leave the description stating the old ceiling. A tool that never capped
-    /// (<c>ValidateUncappedWindow</c>) states no ceiling and is skipped; a tool whose row stays at the default states none either.
+    /// Review r1 M6, as moved by r3: no MCP tool states a reach its <see cref="WebReadReach"/> row does not hold, so raising or
+    /// lowering a row cannot leave a description stating the old ceiling. The number is not in the <c>hours_back</c> parameter's
+    /// description (that line is in every <c>tools/list</c> answer, and <c>McpToolsListBudgetTests</c> holds it at "Hours of history.
+    /// Default N."): a raised tool that has a reading guide states it there, as "hours_back reaches N", after its
+    /// <c>&lt;&lt;GUIDE&gt;&gt;</c> marker (get_tool_guide serves it); a raised tool with no guide states none, because a guide would cost
+    /// every <c>tools/list</c> answer a pointer sentence, and its refusal past the row names the ceiling. A tool that never capped
+    /// (<c>ValidateUncappedWindow</c>) states no ceiling and is skipped.
     /// </summary>
     [Fact]
-    public void EveryRaisedTool_HoursBackDescription_NamesItsRowsNumber_AndNoOtherToolClaimsAHigherOne()
+    public void EveryRaisedTool_StatesItsRowsNumberInTheGuideTail_NeverInTheHead_AndNoToolClaimsMoreThanItsRow()
     {
         var tools = typeof(WebReadReach).Assembly.GetTypes()
             .SelectMany(t => t.GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic))
@@ -159,6 +163,7 @@ public void EveryRaisedTool_HoursBackDescription_NamesItsRowsNumber_AndNoOtherTo
             .ToDictionary(x => x.Attr!.Name!, x => x.Method, StringComparer.Ordinal);
         var uncapped = new[] { "get_blocking_stats" };
         var raised = 0;
+        var guided = 0;
         foreach (var (read, reach) in WebReadReach.All)
         {
             if (!tools.TryGetValue(read, out var method))
@@ -174,21 +179,35 @@ public void EveryRaisedTool_HoursBackDescription_NamesItsRowsNumber_AndNoOtherTo
                 continue;
             }
 
-            var claim = Regex.Match(description, @"up to (?<n>\d+)");
+            var toolDescription = ((System.ComponentModel.DescriptionAttribute?)Attribute.GetCustomAttribute(method, typeof(System.ComponentModel.DescriptionAttribute)))?.Description ?? string.Empty;
+            var marker = toolDescription.IndexOf(McpToolGuide.Marker, StringComparison.Ordinal);
+
+            /* The head (the parameter line, and the tool's text before its marker) states no reach: it is in every tools/list answer. */
+            var head = description + " " + (marker >= 0 ? toolDescription[..marker] : toolDescription);
+            Assert.False(
+                Regex.Matches(head, @"(?:up to|reaches) (?<n>\d+)").Any(m => int.Parse(m.Groups["n"].Value, System.Globalization.CultureInfo.InvariantCulture) > McpHelpers.MaxHoursBack),
+                $"{read}: the tools/list head states a reach ('{description}'); move it after the tool's <<GUIDE>> marker.");
+
+            var claim = marker >= 0 ? Regex.Match(toolDescription[marker..], @"hours_back reaches (?<n>\d+)") : Match.Empty;
             if (reach.MaxHours > McpHelpers.MaxHoursBack)
             {
                 raised++;
-                Assert.True(claim.Success && claim.Groups["n"].Value == reach.MaxHours.ToString(System.Globalization.CultureInfo.InvariantCulture),
-                    $"{read}: hours_back says '{description}' but its WebReadReach row holds {reach.MaxHours}.");
+                if (marker >= 0)
+                {
+                    guided++;
+                    Assert.True(claim.Success && claim.Groups["n"].Value == reach.MaxHours.ToString(System.Globalization.CultureInfo.InvariantCulture),
+                        $"{read}: its guide tail says '{(claim.Success ? claim.Value : "nothing")}' but its WebReadReach row holds {reach.MaxHours}.");
+                }
             }
             else if (claim.Success)
             {
                 Assert.True(int.Parse(claim.Groups["n"].Value, System.Globalization.CultureInfo.InvariantCulture) <= reach.MaxHours,
-                    $"{read}: hours_back says '{description}' but its WebReadReach row holds only {reach.MaxHours}.");
+                    $"{read}: its guide tail says '{claim.Value}' but its WebReadReach row holds only {reach.MaxHours}.");
             }
         }
 
         Assert.True(raised >= 14, $"Only {raised} raised tools had an hours_back description to check; the reflection missed them.");
+        Assert.True(guided >= 7, $"Only {guided} raised tools carry their reach in a guide tail.");
     }
 
     /// <summary>
diff --git a/Darling/Darling.Tests/WebServerPageRangeTests.cs b/Darling/Darling.Tests/WebServerPageRangeTests.cs
index 4d7b045ac9..1ecd5f0345 100644
--- a/Darling/Darling.Tests/WebServerPageRangeTests.cs
+++ b/Darling/Darling.Tests/WebServerPageRangeTests.cs
@@ -167,18 +167,24 @@ public void TheOfferedRanges_InTheSource_AreTheTabsReachFromTheCatalog()
     public void ATab_NamesItsReads_AndNeverTypesItsHours()
     {
         var tabs = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tabs.js");
+        var reach = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tab-reach.js");
         var findings = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "analysis-findings.js");
         var server = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server.js");
 
         var hand = new Regex(@"\b(reach|reachHours|reachReads|maxHours|max_hours)\s*[:=]\s*[0-9]", RegexOptions.CultureInvariant);
-        foreach (var (file, text) in new[] { ("server-tabs.js", tabs), ("analysis-findings.js", findings), ("server.js", server) })
+        foreach (var (file, text) in new[] { ("server-tabs.js", tabs), ("server-tab-reach.js", reach), ("analysis-findings.js", findings), ("server.js", server) })
         {
             var typed = hand.Matches(text).Select(m => m.Value).ToArray();
             Assert.True(typed.Length == 0, $"{file} types a reach as a number ({string.Join("; ", typed)}); a tab's reach is the catalog's max_hours of its reachReads.");
         }
 
-        /* Each registry tab declares reachReads (the whole registry is 12 + 8 tabs; the Recommendations tab lives in its own module). */
-        var declared = Regex.Matches(tabs, @"reachReads:\s*\[([^\]]*)\]", RegexOptions.CultureInvariant);
+        /* Each registry tab declares reachReads, in server-tab-reach.js and not on the tab objects (the whole registry is 12 + 8 tabs; the
+           Recommendations tab lives in its own module): server-tabs.js is read as text by the pins that count a tab's fetches, and a
+           reach list there would read as a second fetch of every name in it. The registry applies the table to its tabs at load. */
+        Assert.DoesNotContain("reachReads:", tabs, System.StringComparison.Ordinal);
+        Assert.Contains("withTabReach(SERVER_TABS, SQL_TAB_REACH);", tabs, System.StringComparison.Ordinal);
+        Assert.Contains("withTabReach(POSTGRES_TABS, POSTGRES_TAB_REACH);", tabs, System.StringComparison.Ordinal);
+        var declared = Regex.Matches(reach,@"reachReads:\s*\[([^\]]*)\]", RegexOptions.CultureInvariant);
         Assert.True(declared.Count >= 15, $"Only {declared.Count} tabs declare reachReads.");
         Assert.Contains("reachReads: [\"get_analysis_findings\"]", findings, System.StringComparison.Ordinal);
 
@@ -231,20 +237,21 @@ public void ATabsReach_IsTheSmallestOfItsReads_FromTheCatalog()
     /// <summary>The reads a tab declares, from the registry source: the tab key is "engine id" as the harness names it.</summary>
     private static string[] TabReads(string key)
     {
-        var tabs = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tabs.js");
+        var tabs = ReadRepoFile("Darling", "PerformanceMonitor.Darling.Service", "wwwroot", "js", "pages", "server-tab-reach.js");
         var postgres = key.StartsWith("PostgreSQL ", System.StringComparison.Ordinal);
         var id = key[(key.LastIndexOf(' ') + 1)..];
-        var registry = tabs[tabs.IndexOf("export const POSTGRES_TABS", System.StringComparison.Ordinal)..];
-        var sql = tabs[..tabs.IndexOf("export const POSTGRES_TABS", System.StringComparison.Ordinal)];
+        var registry = tabs[tabs.IndexOf("export const POSTGRES_TAB_REACH", System.StringComparison.Ordinal)..];
+        var sql = tabs[..tabs.IndexOf("export const POSTGRES_TAB_REACH", System.StringComparison.Ordinal)];
         var source = postgres ? registry : sql;
         if (key.StartsWith("SQL Server recommendations", System.StringComparison.Ordinal))
         {
             return ["get_analysis_findings"];
         }
 
-        var match = Regex.Match(source, "    id: \"" + Regex.Escape(id) + "\",.*?(?:reachReads: \\[([^\\]]*)\\])?\\s*,?\\s*build", RegexOptions.Singleline | RegexOptions.CultureInvariant);
-        return match.Success && match.Groups[1].Success
-            ? Regex.Matches(match.Groups[1].Value, "\"([a-z_]+)\"").Select(m => m.Groups[1].Value).ToArray()
+        var tab = Regex.Match(source, "\\n  " + Regex.Escape(id) + ": \\{(?<body>.*?)\\n  \\}", RegexOptions.Singleline | RegexOptions.CultureInvariant);
+        var list = tab.Success ? Regex.Match(tab.Groups["body"].Value, "reachReads: \\[([^\\]]*)\\]", RegexOptions.CultureInvariant) : Match.Empty;
+        return list.Success
+            ? Regex.Matches(list.Groups[1].Value, "\"([a-z_]+)\"").Select(m => m.Groups[1].Value).ToArray()
             : [];
     }
 
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
index 94e5d09aa2..82d86c8ebd 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
@@ -76,11 +76,11 @@ namespace PerformanceMonitor.Darling.Service.Mcp;
 [McpServerToolType]
 public sealed class DarlingMcpAlertTools
 {
-    [McpServerTool(Name = "get_alert_history"), Description("Gets alert history, NEWEST FIRST: each row FIRED; notification_type says whether it was DELIVERED, a separate question from DISMISSED (UI-acknowledged), excluded by default. THE PAGE IS BOUNDED BY limit, NOT hours_back: truncated says the window held more, and oldest/newest_returned_alert_time bound how far the page reached. An EMPTY page can mean no alerts fired, or that every alert here was dismissed: dismissed_excluded_count says which; include_dismissed = true returns them, labelled dismissed = true. A null send_error proves nothing about delivery.<<GUIDE>>Gets recent alert history from the alert log, NEWEST FIRST: what alerts fired, when, for which server, the current vs threshold value, whether email/webhook delivery succeeded, and whether the alert was muted. Omit server_name to see the whole fleet (each row names its server); pass one to scope to a single server. THE PAGE IS BOUNDED BY limit, NOT BY hours_back: alerts_returned is how many rows you got, truncated says the window held more than limit, and oldest_returned_alert_time / newest_returned_alert_time bound the page — under newest-first ordering the oldest stamp IS how far back this read reached, so on a noisy fleet a 24-hour request at the default limit may cover minutes. Raise limit or narrow hours_back when truncated is true; widening hours_back cannot help. BY DEFAULT THIS READ EXCLUDES DISMISSED ALERTS — rows an operator acknowledged in the Viewer's Alert History grid. Dismissal says nothing about whether the alert fired or mattered, so an incident reconstruction that ignores it can miss the very critical someone already looked at: dismissed_excluded says whether the filter applied and dismissed_excluded_count is how many rows in the window it removed, and include_dismissed = true returns them, each labelled dismissed = true. notification_type is the delivery disposition and is the ONLY field that says why a row did not deliver: 'email'/'webhook'/'email+webhook' delivered on that channel; 'throttled' means the delivery cooldown was still inside this alert's window so nothing was attempted (the throttle working, not a fault); 'folded' means a repeat was rolled onto another server's post for the same metric and is named there under 'Other Servers Affected', so it WAS reported; 'failed' means a channel was attempted and came back unsuccessful, with send_error carrying the first failing channel's text; 'unconfigured' means no email or webhook channel is set up; 'muted' means a mute rule suppressed it; 'digest' means the analysis finding was UNCORROBORATED (one fact in its chain, no matched co-fire check) and the corroboration gate routed it to the daily Analysis Singles Digest and the web/MCP surfaces instead of a paging channel — nothing was attempted, nothing was suppressed, and routing_reason on the row says which components decided; 'none' is a resolution row, which no channel applies to. Do NOT split the not-delivered rows on send_error: it is null on 'throttled', 'folded' and 'digest' rows and on every row written before those values existed, so a null error is not evidence of a working cooldown. 'undelivered' is a retained legacy value that means throttled OR folded OR failed with nothing in the row to say which — count those rows separately rather than attributing them. severity is the row's tier — 'critical', 'warning', 'info' or 'resolution' — and severity_source says where it came from: 'fired' when the row persisted the tier the alert actually fired at (graded alerts such as Poison Wait, Volume Free Space and Database State fire Warning OR Critical by measurement), 'metric_name' when the row carries no tier and the metric's name is the only evidence (rows written before the tier was persisted, alerts whose severity is fixed per metric, and every resolution row). Do not infer a graded alert's tier from its name: a 'Poison Wait' row with severity 'warning' fired as a warning. route says WHERE the posts went: the alert's family (self-monitor / reports / agent-jobs / performance), the notification route that matched it (route_id null = the parent channels in Settings > Notifications answered everything) and each delivered channel with the route that supplied its destination — see get_notification_routes for the taxonomy and the routes. route is null on rows written before routing existed and on rows that never reached a delivery decision (throttled, folded, muted, unconfigured, digest, resolutions), so a null route is not evidence of a routing fault. routing is a DIFFERENT question from route: for an 'Analysis: …' finding it is the corroboration gate's decision one step UPSTREAM of the fan-out — 'page' when the finding earned a channel (two or more facts in its chain, or a matched co-fire check, or one of the two by-construction stories) and 'digest' when it was a lone uncorroborated fact — with routing_reason naming the components the gate read, so 'why didn't this page' is answered by the row. Both are null on every engine alert and on analysis rows written before the gate existed. To see what the digest carried, read the rows with notification_type 'digest' in the window: each is a persisted finding with its full detail_text and context, findable in get_analysis_findings by the story hash in its metric_name. Dismissal is an acknowledgement, not a verdict — a dismissed critical still fired — so set this when reconstructing an incident rather than triaging what is still open. Each row then carries dismissed so the two populations stay distinguishable.")]
+    [McpServerTool(Name = "get_alert_history"), Description("Gets alert history, NEWEST FIRST: each row FIRED; notification_type says whether it was DELIVERED, a separate question from DISMISSED (UI-acknowledged), excluded by default. THE PAGE IS BOUNDED BY limit, NOT hours_back: truncated says the window held more, and oldest/newest_returned_alert_time bound how far the page reached. An EMPTY page can mean no alerts fired, or that every alert here was dismissed: dismissed_excluded_count says which; include_dismissed = true returns them, labelled dismissed = true. A null send_error proves nothing about delivery.<<GUIDE>> hours_back reaches 2160 (90 days, the alert table's retention). Gets recent alert history from the alert log, NEWEST FIRST: what alerts fired, when, for which server, the current vs threshold value, whether email/webhook delivery succeeded, and whether the alert was muted. Omit server_name to see the whole fleet (each row names its server); pass one to scope to a single server. THE PAGE IS BOUNDED BY limit, NOT BY hours_back: alerts_returned is how many rows you got, truncated says the window held more than limit, and oldest_returned_alert_time / newest_returned_alert_time bound the page — under newest-first ordering the oldest stamp IS how far back this read reached, so on a noisy fleet a 24-hour request at the default limit may cover minutes. Raise limit or narrow hours_back when truncated is true; widening hours_back cannot help. BY DEFAULT THIS READ EXCLUDES DISMISSED ALERTS — rows an operator acknowledged in the Viewer's Alert History grid. Dismissal says nothing about whether the alert fired or mattered, so an incident reconstruction that ignores it can miss the very critical someone already looked at: dismissed_excluded says whether the filter applied and dismissed_excluded_count is how many rows in the window it removed, and include_dismissed = true returns them, each labelled dismissed = true. notification_type is the delivery disposition and is the ONLY field that says why a row did not deliver: 'email'/'webhook'/'email+webhook' delivered on that channel; 'throttled' means the delivery cooldown was still inside this alert's window so nothing was attempted (the throttle working, not a fault); 'folded' means a repeat was rolled onto another server's post for the same metric and is named there under 'Other Servers Affected', so it WAS reported; 'failed' means a channel was attempted and came back unsuccessful, with send_error carrying the first failing channel's text; 'unconfigured' means no email or webhook channel is set up; 'muted' means a mute rule suppressed it; 'digest' means the analysis finding was UNCORROBORATED (one fact in its chain, no matched co-fire check) and the corroboration gate routed it to the daily Analysis Singles Digest and the web/MCP surfaces instead of a paging channel — nothing was attempted, nothing was suppressed, and routing_reason on the row says which components decided; 'none' is a resolution row, which no channel applies to. Do NOT split the not-delivered rows on send_error: it is null on 'throttled', 'folded' and 'digest' rows and on every row written before those values existed, so a null error is not evidence of a working cooldown. 'undelivered' is a retained legacy value that means throttled OR folded OR failed with nothing in the row to say which — count those rows separately rather than attributing them. severity is the row's tier — 'critical', 'warning', 'info' or 'resolution' — and severity_source says where it came from: 'fired' when the row persisted the tier the alert actually fired at (graded alerts such as Poison Wait, Volume Free Space and Database State fire Warning OR Critical by measurement), 'metric_name' when the row carries no tier and the metric's name is the only evidence (rows written before the tier was persisted, alerts whose severity is fixed per metric, and every resolution row). Do not infer a graded alert's tier from its name: a 'Poison Wait' row with severity 'warning' fired as a warning. route says WHERE the posts went: the alert's family (self-monitor / reports / agent-jobs / performance), the notification route that matched it (route_id null = the parent channels in Settings > Notifications answered everything) and each delivered channel with the route that supplied its destination — see get_notification_routes for the taxonomy and the routes. route is null on rows written before routing existed and on rows that never reached a delivery decision (throttled, folded, muted, unconfigured, digest, resolutions), so a null route is not evidence of a routing fault. routing is a DIFFERENT question from route: for an 'Analysis: …' finding it is the corroboration gate's decision one step UPSTREAM of the fan-out — 'page' when the finding earned a channel (two or more facts in its chain, or a matched co-fire check, or one of the two by-construction stories) and 'digest' when it was a lone uncorroborated fact — with routing_reason naming the components the gate read, so 'why didn't this page' is answered by the row. Both are null on every engine alert and on analysis rows written before the gate existed. To see what the digest carried, read the rows with notification_type 'digest' in the window: each is a persisted finding with its full detail_text and context, findable in get_analysis_findings by the story hash in its metric_name. Dismissal is an acknowledgement, not a verdict — a dismissed critical still fired — so set this when reconstructing an incident rather than triaging what is still open. Each row then carries dismissed so the two populations stay distinguishable.")]
     public static async Task<string> GetAlertHistory(
         NpgsqlDataSource postgres,
         [Description("Server name or display name. Omit to return alerts across all servers (the fleet default).")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 2160 (90 days, the alert table's retention).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description("Maximum rows to return, newest first. Default 50. This is what bounds the page — read truncated to know whether the window held more.")] int limit = 50,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         /* Appended after as_of for the reason get_collection_log's filters are: MCP invokes by name, the
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs
index a221d9fcd8..def5ac516a 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpBlockingTools.cs
@@ -804,7 +804,7 @@ XML in the window than limit". */
     public static Task<string> GetBlockingTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
         CancellationToken cancellationToken = default) =>
@@ -879,7 +879,7 @@ means nothing at all is known about the window. The stored tables cannot tell th
     public static async Task<string> GetDeadlockTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         CancellationToken cancellationToken = default)
     {
@@ -933,7 +933,7 @@ where it modifies the collector rather than the event. */
     public static Task<string> GetLockWaitTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs
index 09079bfcc5..fd0fb37d84 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpDataTools.cs
@@ -60,7 +60,7 @@ public sealed class DarlingMcpDataTools
     public static Task<string> GetCpuUtilization(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 4; up to 720 (30 days).")] int hours_back = 4,
+        [Description("Hours of history. Default 4.")] int hours_back = 4,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -242,7 +242,7 @@ public static Task<string> GetWaitTrend(
         NpgsqlDataSource postgres,
         [Description("The exact wait type name, e.g. CXPACKET, PAGEIOLATCH_SH.")] string wait_type,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -529,7 +529,7 @@ itself is a pre-V127 row that never recorded one. */
     public static Task<string> GetTempDbTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
index 0e3faf07c7..38d1a21dd4 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
@@ -44,11 +44,11 @@ namespace PerformanceMonitor.Darling.Service.Mcp;
 [McpServerToolType]
 public sealed class DarlingMcpPgCpuUtilizationTools
 {
-    [McpServerTool(Name = "get_pg_cpu_utilization"), Description("Gets instance-level CPU for a PostgreSQL/Aurora target from AWS Performance Insights, in time buckets (bucket_minutes) to as_of. Aurora only; RDS and self-hosted are not_collected. cpu_percent is percent of capacity CURRENTLY ALLOCATED, not a fixed ceiling - on Serverless v2 that moves, so 100% is often a scale-up, not saturation. acu_utilization_percent is percent of the CONFIGURED ceiling, the saturation figure; null ACU means no sample, never headroom. Host-memory bytes (since V136) are null when unmeasured; memory_samples_in_bucket is the count. <<GUIDE>> Gets instance-level CPU utilization over time for a PostgreSQL/Aurora target, from AWS Performance Insights, bucketed to a point budget the same way get_cpu_utilization is (#4193, the #3897 TrendBuckets contract) rather than one row per raw 1-minute sample. Aurora only - a plain RDS or self-hosted target has no route here and this is not_collected for it; Performance Insights could reach plain RDS too, but no monitored target is that shape yet. cpu_percent is os.cpuUtilization.total.avg, which is percent of the capacity CURRENTLY ALLOCATED: on Aurora Serverless v2 that allocation moves, so 100% is routinely a scale-up rather than saturation. acu_utilization_percent (os.general.acuUtilization.avg) is percent of the CONFIGURED ACU ceiling and is the saturation figure - band and alert on that one. Both are reported per bucket as the AVERAGE of the bucket's samples, with peak_cpu_percent/peak_acu_utilization_percent holding the single busiest sample, so a saturation minute is never averaged away by a wide bucket; a null ACU figure means no capacity sample in that bucket, never headroom. Since V136 the same row carries the HOST'S MEMORY from Performance Insights' os.memory.* counters, in bytes: memory_total_bytes, memory_cached_bytes, memory_buffers_bytes and configured_memory_bytes are the bucket's average; memory_free_bytes and memory_active_bytes are its WORST sample (minimum free, maximum active) rather than an average, so a brief pressure spike survives a wide bucket - the figures the PG_HOST_MEMORY_PRESSURE and CONFIG_PG_MEMORY_OVERCOMMIT facts are measured against (get_analysis_facts source=pg_memory). Every memory figure is null on a pre-V136 row or an endpoint without os.memory.*, and null means not measured, never zero memory; memory_samples_in_bucket says how many samples carried it.")]
+    [McpServerTool(Name = "get_pg_cpu_utilization"), Description("Gets instance-level CPU for a PostgreSQL/Aurora target from AWS Performance Insights, in time buckets (bucket_minutes) to as_of. Aurora only; RDS and self-hosted are not_collected. cpu_percent is percent of capacity CURRENTLY ALLOCATED, not a fixed ceiling - on Serverless v2 that moves, so 100% is often a scale-up, not saturation. acu_utilization_percent is percent of the CONFIGURED ceiling, the saturation figure; null ACU means no sample, never headroom. Host-memory bytes (since V136) are null when unmeasured; memory_samples_in_bucket is the count. <<GUIDE>> hours_back reaches 720 (30 days). Gets instance-level CPU utilization over time for a PostgreSQL/Aurora target, from AWS Performance Insights, bucketed to a point budget the same way get_cpu_utilization is (#4193, the #3897 TrendBuckets contract) rather than one row per raw 1-minute sample. Aurora only - a plain RDS or self-hosted target has no route here and this is not_collected for it; Performance Insights could reach plain RDS too, but no monitored target is that shape yet. cpu_percent is os.cpuUtilization.total.avg, which is percent of the capacity CURRENTLY ALLOCATED: on Aurora Serverless v2 that allocation moves, so 100% is routinely a scale-up rather than saturation. acu_utilization_percent (os.general.acuUtilization.avg) is percent of the CONFIGURED ACU ceiling and is the saturation figure - band and alert on that one. Both are reported per bucket as the AVERAGE of the bucket's samples, with peak_cpu_percent/peak_acu_utilization_percent holding the single busiest sample, so a saturation minute is never averaged away by a wide bucket; a null ACU figure means no capacity sample in that bucket, never headroom. Since V136 the same row carries the HOST'S MEMORY from Performance Insights' os.memory.* counters, in bytes: memory_total_bytes, memory_cached_bytes, memory_buffers_bytes and configured_memory_bytes are the bucket's average; memory_free_bytes and memory_active_bytes are its WORST sample (minimum free, maximum active) rather than an average, so a brief pressure spike survives a wide bucket - the figures the PG_HOST_MEMORY_PRESSURE and CONFIG_PG_MEMORY_OVERCOMMIT facts are measured against (get_analysis_facts source=pg_memory). Every memory figure is null on a pre-V136 row or an endpoint without os.memory.*, and null means not measured, never zero memory; memory_samples_in_bucket says how many samples carried it.")]
     public static Task<string> GetPgCpuUtilization(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 4; up to 720 (30 days).")] int hours_back = 4,
+        [Description("Hours of history. Default 4.")] int hours_back = 4,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         ILogger? logger = null,
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
index 019ea4f05c..ddf36e9bd0 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
@@ -255,13 +255,13 @@ statement that does not exist. */
         }
     }
 
-    [McpServerTool(Name = "get_pg_io_trend"), Description("Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io: read/write/extend rates per second, cache-hit ratio, per-op latency, bucketed to as_of. Requires PostgreSQL 16+. avg_read_ms/avg_write_ms are null, never 0.000, when track_io_timing is off. Write fields are null, not 0, on Amazon Aurora (no write counters). Byte rates: measured (18+), estimated (earlier), or null. Empty: no pair was active, or the window holds one snapshot (a trend needs two to difference). A point spanning a stats reset reports everything since the reset, not a quiet interval. <<GUIDE>> Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io, in time buckets: read, write and extend rates per second, the buffer-cache hit ratio for each point, and per-operation latency where the server measures it. Use get_pg_io_stats first to see which combinations are busy, then this to see whether one is growing or slowing. The subject is a PAIR because a hit ratio summed across contexts is meaningless - bulkread is a sequential scan deliberately bypassing the buffer pool with a ring buffer, so averaging its misses with the normal context's understates both and they have opposite remedies. Object types are summed together, which cannot distort the ratio because WAL rows report no buffer hits. Reports whether the server tracks I/O TIMING at all: track_io_timing is OFF by default in PostgreSQL, and its zero read_time would otherwise divide out to a latency of 0.000 ms that reads as an impossibly fast disk rather than an unmeasured one. Also reports whether byte volumes are MEASURED (PostgreSQL 18's read_bytes/write_bytes) or ESTIMATED as operations x block size (pre-18) - the two are different quantities and 18 moves several blocks per operation, so the older estimate undercounts there. Write counters are null rather than zero on Amazon Aurora, where backends do not write data files. A point holding an interval that spans a pg_stat_reset_shared('io') or a restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Requires PostgreSQL 16 or later; valid on a standby. On backend_type: Naming this alone follows the busiest CONTEXT for that backend; omit both to follow whichever pair moved the most I/O.")]
+    [McpServerTool(Name = "get_pg_io_trend"), Description("Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io: read/write/extend rates per second, cache-hit ratio, per-op latency, bucketed to as_of. Requires PostgreSQL 16+. avg_read_ms/avg_write_ms are null, never 0.000, when track_io_timing is off. Write fields are null, not 0, on Amazon Aurora (no write counters). Byte rates: measured (18+), estimated (earlier), or null. Empty: no pair was active, or the window holds one snapshot (a trend needs two to difference). A point spanning a stats reset reports everything since the reset, not a quiet interval. <<GUIDE>> hours_back reaches 720 (30 days). Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io, in time buckets: read, write and extend rates per second, the buffer-cache hit ratio for each point, and per-operation latency where the server measures it. Use get_pg_io_stats first to see which combinations are busy, then this to see whether one is growing or slowing. The subject is a PAIR because a hit ratio summed across contexts is meaningless - bulkread is a sequential scan deliberately bypassing the buffer pool with a ring buffer, so averaging its misses with the normal context's understates both and they have opposite remedies. Object types are summed together, which cannot distort the ratio because WAL rows report no buffer hits. Reports whether the server tracks I/O TIMING at all: track_io_timing is OFF by default in PostgreSQL, and its zero read_time would otherwise divide out to a latency of 0.000 ms that reads as an impossibly fast disk rather than an unmeasured one. Also reports whether byte volumes are MEASURED (PostgreSQL 18's read_bytes/write_bytes) or ESTIMATED as operations x block size (pre-18) - the two are different quantities and 18 moves several blocks per operation, so the older estimate undercounts there. Write counters are null rather than zero on Amazon Aurora, where backends do not write data files. A point holding an interval that spans a pg_stat_reset_shared('io') or a restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Requires PostgreSQL 16 or later; valid on a standby. On backend_type: Naming this alone follows the busiest CONTEXT for that backend; omit both to follow whichever pair moved the most I/O.")]
     public static Task<string> GetPgIoTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
         [Description("Which backend did the I/O, e.g. 'client backend', 'autovacuum worker', 'checkpointer'.")] string? backend_type = null,
         [Description("Why the I/O happened: normal, bulkread, bulkwrite, vacuum, index, walreplay. Naming this alone follows the busiest BACKEND in that context; omit both to follow whichever pair moved the most I/O.")] string? context = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -519,12 +519,12 @@ survives the bucket. The latency peak is nulled on the same rule as avg_read_ms.
         }
     }
 
-    [McpServerTool(Name = "get_pg_database_trend"), Description("Gets a time series for ONE PostgreSQL database from pg_stat_database: temp-file spills, cache-hit ratio, deadlocks and rollback share, bucketed to as_of. Differenced per interval - the raw counters are cumulative, and a real cliff averages out otherwise. cache_hit_pct/rollback_pct are null, not 0, on an interval with no accesses or no completed transactions. deadlocks is a COUNT per point, not a rate. A point spanning a stats reset reports everything since, never a quiet interval. Empty: wrong name, only one snapshot so far, or none in the window - the message says which. <<GUIDE>> Gets a time series for ONE PostgreSQL database from pg_stat_database, in time buckets: temp-file spills, the buffer-cache hit ratio (with each bucket's worst interval), deadlocks and the rollback share. This is where the cache hit ratio becomes usable at all - pg_stat_database's counters are cumulative since the last reset, so the ratio computed from them raw is a lifetime average that barely moves, and a database that fell off a cliff an hour ago still reports 99% because of the weeks behind it. Differenced per interval, the cliff is visible. Temp files are the same story: 'this database spilled 40 GB this week' does not say whether it was one bad afternoon or a steady leak, and the two have different fixes. Deadlocks are reported as a COUNT per point rather than a rate, because they are discrete server-recorded events. Omit database to follow the biggest temp-file spiller. PostgreSQL's shared-relations row - the cluster-wide catalog, which has a NULL database name - is followable by passing '(shared relations)' but is never chosen automatically. A point holding an interval that spans a pg_stat_reset or a crash restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Works on every PostgreSQL major and on a standby, where sorts spill exactly the way they do on a writer.")]
+    [McpServerTool(Name = "get_pg_database_trend"), Description("Gets a time series for ONE PostgreSQL database from pg_stat_database: temp-file spills, cache-hit ratio, deadlocks and rollback share, bucketed to as_of. Differenced per interval - the raw counters are cumulative, and a real cliff averages out otherwise. cache_hit_pct/rollback_pct are null, not 0, on an interval with no accesses or no completed transactions. deadlocks is a COUNT per point, not a rate. A point spanning a stats reset reports everything since, never a quiet interval. Empty: wrong name, only one snapshot so far, or none in the window - the message says which. <<GUIDE>> hours_back reaches 720 (30 days). Gets a time series for ONE PostgreSQL database from pg_stat_database, in time buckets: temp-file spills, the buffer-cache hit ratio (with each bucket's worst interval), deadlocks and the rollback share. This is where the cache hit ratio becomes usable at all - pg_stat_database's counters are cumulative since the last reset, so the ratio computed from them raw is a lifetime average that barely moves, and a database that fell off a cliff an hour ago still reports 99% because of the weeks behind it. Differenced per interval, the cliff is visible. Temp files are the same story: 'this database spilled 40 GB this week' does not say whether it was one bad afternoon or a steady leak, and the two have different fixes. Deadlocks are reported as a COUNT per point rather than a rate, because they are discrete server-recorded events. Omit database to follow the biggest temp-file spiller. PostgreSQL's shared-relations row - the cluster-wide catalog, which has a NULL database name - is followable by passing '(shared relations)' but is never chosen automatically. A point holding an interval that spans a pg_stat_reset or a crash restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Works on every PostgreSQL major and on a standby, where sorts spill exactly the way they do on a writer.")]
     public static Task<string> GetPgDatabaseTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
         [Description("The database to follow. Pass '(shared relations)' for PostgreSQL's cluster-wide catalog row. Omit to follow the biggest temp-file spiller in the window.")] string? database = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
index 5fdf6dced7..7cf577e6db 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
@@ -98,7 +98,7 @@ public sealed class DarlingMcpTrendTools
     public static Task<string> GetMemoryTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         CancellationToken cancellationToken = default) =>
@@ -274,7 +274,7 @@ deltas and the seconds they accrued over (#3960), so that division still holds p
     public static Task<string> GetFileIoTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 720 (30 days).")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         [Description("One database, charted per file. Omit for every database.")] string? database_name = null,
@@ -498,11 +498,11 @@ want opposite remedies — see the class remarks and McpHelpers.WindowTruncatedD
         }
     }
 
-    [McpServerTool(Name = "get_query_duration_trend"), Description("Gets a time-series of query elapsed_ms_per_second and executions_per_second across all queries, points ending at as_of. A collection whose interval was unknowable is excluded, not counted as 0: unrated_collections counts it, and a point left with nothing else carries null rates (unrated_points), never zero. No points: unavailable means query_stats was never collected here; empty means it was (the message says quiet window or rollup coverage gap). window_truncated is the store's retention floor, not a page cut: effective_start / effective_hours_back say where the answer begins. <<GUIDE>> Gets a time-series of average query duration over time. Useful for spotting overall performance degradation or improvement trends across all queries. Points are time buckets (bucket, aggregate_note); rates are over each collection's STORED sample interval, and a collection whose interval was unknowable - a restart or counter reset, or the window's first collection when none was stored - is left out rather than counted as 0 (unrated_collections counts them; a point with nothing else carries null rates, unrated_points). The hourly rollup route divides by the bucket width and has no unrated point." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
+    [McpServerTool(Name = "get_query_duration_trend"), Description("Gets a time-series of query elapsed_ms_per_second and executions_per_second across all queries, points ending at as_of. A collection whose interval was unknowable is excluded, not counted as 0: unrated_collections counts it, and a point left with nothing else carries null rates (unrated_points), never zero. No points: unavailable means query_stats was never collected here; empty means it was (the message says quiet window or rollup coverage gap). window_truncated is the store's retention floor, not a page cut: effective_start / effective_hours_back say where the answer begins. <<GUIDE>> hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Gets a time-series of average query duration over time. Useful for spotting overall performance degradation or improvement trends across all queries. Points are time buckets (bucket, aggregate_note); rates are over each collection's STORED sample interval, and a collection whose interval was unknowable - a restart or counter reset, or the window's first collection when none was stored - is left out rather than counted as 0 (unrated_collections counts them; a point with nothing else carries null rates, unrated_points). The hourly rollup route divides by the bucket width and has no unrated point." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
     public static Task<string> GetQueryDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 2160 (90 days), served from the hourly rollup past the raw tier's four days.")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
@@ -598,11 +598,11 @@ is not a server nothing was ever stored for. */
         }
     }
 
-    [McpServerTool(Name = "get_procedure_duration_trend"), Description("Gets a time-series of stored-procedure elapsed_ms_per_second and executions_per_second, summed across every procedure and charged to the whole call rather than smeared across its statements the way query_stats attributes work. Points end at as_of. unrated_points, unrated_collections, the empty/unavailable split and window_truncated (a retention floor, not a page cut) all follow get_query_duration_trend exactly. <<GUIDE>> Gets a time-series of stored-procedure elapsed time per second and executions per second over time, summed across every procedure. The sibling of get_query_duration_trend, and NOT a duplicate of it: query_stats attributes a procedure's work to the individual statements inside it, so a procedure that got slower is smeared across however many statements it runs. This charges the whole call to the procedure. Read the two together to tell an ad-hoc SQL regression from a procedure regression. Points, rates and unrated collections (unrated_points, unrated_collections) follow get_query_duration_trend exactly." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
+    [McpServerTool(Name = "get_procedure_duration_trend"), Description("Gets a time-series of stored-procedure elapsed_ms_per_second and executions_per_second, summed across every procedure and charged to the whole call rather than smeared across its statements the way query_stats attributes work. Points end at as_of. unrated_points, unrated_collections, the empty/unavailable split and window_truncated (a retention floor, not a page cut) all follow get_query_duration_trend exactly. <<GUIDE>> hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Gets a time-series of stored-procedure elapsed time per second and executions per second over time, summed across every procedure. The sibling of get_query_duration_trend, and NOT a duplicate of it: query_stats attributes a procedure's work to the individual statements inside it, so a procedure that got slower is smeared across however many statements it runs. This charges the whole call to the procedure. Read the two together to tell an ad-hoc SQL regression from a procedure regression. Points, rates and unrated collections (unrated_points, unrated_collections) follow get_query_duration_trend exactly." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
     public static Task<string> GetProcedureDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 2160 (90 days), served from the hourly rollup past the raw tier's four days.")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description(TrendBuckets.BucketMinutesDescription)] int? bucket_minutes = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
@@ -675,11 +675,11 @@ width rule on the hourly tier. */
         }
     }
 
-    [McpServerTool(Name = "get_query_store_duration_trend"), Description("Gets a time-series of Query Store duration and executions per second, summed across every query, each interval counted once, at the hour it ran. not_collected: engine cannot run Query Store. unavailable: never sampled here. empty: quiet on Lite always; on Darling, empty can also be a rollup coverage gap (window predates the corrected rollup, run --backfill-rollups). Only a point that stored no interval end and has no earlier point to rate against has null rates, never 0 (unrated_points, unrated_note says why). window_truncated marks the retention floor, not a page cut. <<GUIDE>> Gets a time-series of Query Store duration per second and executions per second over time, summed across every query. Where get_query_duration_trend reads the plan cache and loses everything an eviction or a restart takes with it, this reads Query Store, which persists per interval - so it is the series that survives a failover and the one to reach for when a regression is older than the cache. Each interval is counted once, at the hour the work ran. A rollup point (an hourly bucket the corrected rollup has materialized) is rated over its bucket width, so every rollup point is rated, the window's first bucket included; a raw point (a Query Store interval placed at its start, or a legacy row at its collection time) is rated over its own stored interval, its end minus its start. A raw point with no stored end (a row collected before the end was recorded, and every legacy row) falls back to the gap since the PREVIOUS point, so only such a point, when it is first in the window and has no previous one to difference against, carries null rates: unknowable, never reported as 0 (unrated_points counts them, unrated_note says why)." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
+    [McpServerTool(Name = "get_query_store_duration_trend"), Description("Gets a time-series of Query Store duration and executions per second, summed across every query, each interval counted once, at the hour it ran. not_collected: engine cannot run Query Store. unavailable: never sampled here. empty: quiet on Lite always; on Darling, empty can also be a rollup coverage gap (window predates the corrected rollup, run --backfill-rollups). Only a point that stored no interval end and has no earlier point to rate against has null rates, never 0 (unrated_points, unrated_note says why). window_truncated marks the retention floor, not a page cut. <<GUIDE>> hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Gets a time-series of Query Store duration per second and executions per second over time, summed across every query. Where get_query_duration_trend reads the plan cache and loses everything an eviction or a restart takes with it, this reads Query Store, which persists per interval - so it is the series that survives a failover and the one to reach for when a regression is older than the cache. Each interval is counted once, at the hour the work ran. A rollup point (an hourly bucket the corrected rollup has materialized) is rated over its bucket width, so every rollup point is rated, the window's first bucket included; a raw point (a Query Store interval placed at its start, or a legacy row at its collection time) is rated over its own stored interval, its end minus its start. A raw point with no stored end (a row collected before the end was recorded, and every legacy row) falls back to the gap since the PREVIOUS point, so only such a point, when it is first in the window and has no previous one to difference against, carries null rates: unknowable, never reported as 0 (unrated_points counts them, unrated_note says why)." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
     public static Task<string> GetQueryStoreDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
-        [Description("Hours of history. Default 24; up to 2160 (90 days), served from the hourly rollup past the raw tier's four days.")] int hours_back = 24,
+        [Description("Hours of history. Default 24.")] int hours_back = 24,
         [Description(McpHelpers.AsOfDescription)] string? as_of = null,
         [Description("Limit to one database. Omit for all databases.")] string? database_name = null,
         CancellationToken cancellationToken = default) =>
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tab-reach.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tab-reach.js
new file mode 100644
index 0000000000..2021b0d7dd
--- /dev/null
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tab-reach.js
@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2026 Erik Darling, Darling Data LLC
+ *
+ * This file is part of the SQL Server Performance Monitor.
+ *
+ * Licensed under the MIT License. See LICENSE file in the project root for full license information.
+ */
+
+/*
+ * What each server-page tab reads, for its time-range reach (#5562 review r1 M4, ruling R2; moved out of server-tabs.js in r3).
+ *
+ * `reachReads` names the windowed reads a tab makes (names, never hours): the picker offers the tab the smallest `max_hours` the
+ * catalog gives them. `collector` names the collector whose sample interval the picker shows for the tab. They live here, keyed
+ * by tab id, and not on the tab objects in server-tabs.js, because that file is read as text by the pins that count how often a
+ * tab FETCHES a read (a name in a reach list is not a fetch) and that find a tab's neighbouring fields by position. The registry
+ * applies this table to its tabs once, at load (withTabReach), so a tab still carries `reachReads` and `collector` at run time.
+ * WebServerPageRangeTests holds the lists: every name served, every windowed read a tab makes declared.
+ */
+
+/** The SQL Server registry's tabs, by id. */
+export const SQL_TAB_REACH = {
+  overview: {
+    collector: "cpu_utilization",
+    reachReads: [
+      "get_analysis_findings", "get_blocking_trend", "get_cpu_utilization", "get_deadlock_trend",
+      "get_file_io_trend", "get_memory_trend"
+    ]
+  },
+  waits: {
+    collector: "wait_stats",
+    reachReads: [
+      "get_latch_stats", "get_spinlock_stats", "get_wait_stats", "get_wait_trend", "get_waiting_tasks"
+    ]
+  },
+  cpu: {
+    collector: "cpu_utilization",
+    reachReads: [
+      "get_cpu_utilization", "get_server_trend", "get_top_procedures_by_cpu", "get_top_queries_by_cpu"
+    ]
+  },
+  memory: {
+    collector: "memory_stats",
+    reachReads: [
+      "get_memory_grants", "get_memory_pressure_events", "get_memory_trend", "get_plan_cache_bloat",
+      "get_resource_semaphore", "get_server_trend"
+    ]
+  },
+  blocking: {
+    collector: "blocked_process_report",
+    reachReads: [
+      "get_blocked_process_xml", "get_blocking", "get_blocking_stats", "get_blocking_trend",
+      "get_current_waits_trend", "get_deadlock_detail", "get_deadlock_trend", "get_deadlocks",
+      "get_lock_wait_trend"
+    ]
+  },
+  io: {
+    collector: "file_io_stats",
+    reachReads: [
+      "get_file_io_trend", "get_tempdb_trend"
+    ]
+  },
+  queries: {
+    collector: "query_stats",
+    reachReads: [
+      "get_active_queries", "get_long_query_completions", "get_plan_corrections", "get_procedure_duration_trend",
+      "get_query_duration_trend", "get_query_heatmap", "get_query_store_clutter",
+      "get_query_store_duration_trend", "get_query_store_regressions", "get_query_store_top", "get_query_trend",
+      "get_top_procedures_by_cpu", "get_top_queries_by_cpu"
+    ]
+  },
+  changes: {
+    reachReads: [
+      "get_database_config_changes", "get_server_config_changes", "get_trace_flag_changes"
+    ]
+  },
+  activity: {
+    reachReads: [
+      "get_job_history", "get_perfmon_trend", "get_server_trend"
+    ]
+  },
+  events: {
+    reachReads: [
+      "get_default_trace_events", "get_health_parser_cpu_tasks", "get_health_parser_io_issues",
+      "get_health_parser_memory_broker", "get_health_parser_memory_conditions",
+      "get_health_parser_memory_node_oom", "get_health_parser_scheduler_issues",
+      "get_health_parser_severe_errors", "get_health_parser_significant_waits", "get_health_parser_system_health"
+    ]
+  },
+  health: {
+    reachReads: [
+      "get_collection_log"
+    ]
+  }
+};
+
+/** The PostgreSQL registry's tabs, by id. */
+export const POSTGRES_TAB_REACH = {
+  overview: {
+    reachReads: [
+      "get_analysis_findings", "get_collection_log", "get_pg_autovacuum_health", "get_pg_cpu_utilization",
+      "get_pg_extensions", "get_pg_replication_slots", "get_pg_wraparound_risk", "get_pg_xmin_horizon"
+    ]
+  },
+  activity: {
+    reachReads: [
+      "get_pg_blocking", "get_pg_column_stats", "get_pg_database_stats", "get_pg_database_trend",
+      "get_pg_deadlocks", "get_pg_lock_stats", "get_pg_log_events", "get_pg_plan_capture_readiness",
+      "get_pg_plans", "get_pg_predicate_stats", "get_pg_query_duration_trend", "get_pg_top_queries"
+    ]
+  },
+  vacuum: {
+    reachReads: [
+      "get_pg_autovacuum_health", "get_pg_session_states", "get_pg_wraparound_risk", "get_pg_xmin_horizon"
+    ]
+  },
+  waits: {
+    collector: "pg_wait_sampling",
+    reachReads: [
+      "get_pg_kernel_stats", "get_pg_wait_sampling", "get_pg_wait_stats", "get_pg_wait_trend"
+    ]
+  },
+  io: {
+    collector: "pg_io_stats",
+    reachReads: [
+      "get_pg_buffer_usage", "get_pg_io_stats", "get_pg_io_trend", "get_pg_write_stats"
+    ]
+  },
+  replication: {
+    reachReads: [
+      "get_pg_replication_slots", "get_pg_replication_stats"
+    ]
+  },
+  storage: {
+    reachReads: [
+      "get_pg_index_bloat", "get_pg_index_usage", "get_pg_table_bloat"
+    ]
+  },
+  config: {
+    reachReads: [
+      "get_pg_server_config_changes"
+    ]
+  }
+};
+
+/** Puts each tab's reach declaration on the tab object. A tab with no entry is left as it is (it reads at the common reach). */
+export function withTabReach(tabs, reach) {
+  for (const tab of tabs) {
+    if (reach[tab.id]) Object.assign(tab, reach[tab.id]);
+  }
+  return tabs;
+}
diff --git a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
index 8cf57663ca..f3772ae1cf 100644
--- a/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
+++ b/Darling/PerformanceMonitor.Darling.Service/wwwroot/js/pages/server-tabs.js
@@ -50,6 +50,7 @@ import { downloadText } from "../grid-tools.js";
 import { deadlockGraphCell, processRowsInDatabases } from "./deadlock-graph.js";
 import { activePlanColumns, blockingPlanColumns, deadlockPlanColumn, planColumn, procedurePlanColumn, queryStorePlanColumn } from "./plan-viewer.js";
 import { queryStoreHistoryColumn } from "./query-store-history.js";
+import { SQL_TAB_REACH, POSTGRES_TAB_REACH, withTabReach } from "./server-tab-reach.js";
 
 /* ─────────────────────────── shared cell renderers ─────────────────────────── */
 
@@ -1079,11 +1080,6 @@ export const SERVER_TABS = [
   {
     id: "overview",
     label: "Overview",
-    collector: "cpu_utilization",
-    reachReads: [
-      "get_analysis_findings", "get_blocking_trend", "get_cpu_utilization", "get_deadlock_trend",
-      "get_file_io_trend", "get_memory_trend"
-    ],
     build: (server, ctx) => [
       stat("Overview", "get_server_summary", { server }, OVERVIEW_STATS, SNAPSHOT, 2),
       stat("Server Properties", "get_server_properties", { server }, PROPERTY_STATS, SNAPSHOT, 2),
@@ -1132,10 +1128,6 @@ export const SERVER_TABS = [
   {
     id: "waits",
     label: "Wait Stats",
-    collector: "wait_stats",
-    reachReads: [
-      "get_latch_stats", "get_spinlock_stats", "get_wait_stats", "get_wait_trend", "get_waiting_tasks"
-    ],
     build: (server, ctx) => [
       waitsPanel(server, ctx),
       table(
@@ -1173,10 +1165,6 @@ export const SERVER_TABS = [
   {
     id: "cpu",
     label: "CPU",
-    collector: "cpu_utilization",
-    reachReads: [
-      "get_cpu_utilization", "get_server_trend", "get_top_procedures_by_cpu", "get_top_queries_by_cpu"
-    ],
     build: (server, ctx) => [
       line("CPU Utilization", "get_cpu_utilization", { server, hours: ctx.hours }, "samples", "sample_time", CPU_SERIES, {
         subtitle: ctx.label,
@@ -1228,11 +1216,6 @@ export const SERVER_TABS = [
   {
     id: "memory",
     label: "Memory",
-    collector: "memory_stats",
-    reachReads: [
-      "get_memory_grants", "get_memory_pressure_events", "get_memory_trend", "get_plan_cache_bloat",
-      "get_resource_semaphore", "get_server_trend"
-    ],
     build: (server, ctx) => [
       stat("Memory", "get_memory_stats", { server }, MEMORY_STATS, SNAPSHOT, 2),
       line("Memory Trend", "get_memory_trend", { server, hours: ctx.hours }, "trend", "time", MEMORY_SERIES, {
@@ -1323,7 +1306,6 @@ export const SERVER_TABS = [
   {
     id: "blocking",
     label: "Blocking",
-    collector: "blocked_process_report",
     /* get_blocking_stats, which draws Blocking Severity and Deadlock Severity, takes any window, and its tables keep
        more than this page's widest Range. The note names that Range from the presets (tabNote), so narrowing them
        cannot leave it wrong. */
@@ -1332,11 +1314,6 @@ export const SERVER_TABS = [
       "is one of the desktop-viewer features this page does not have. A deadlock graph can be drawn from its row. This page shows at most " +
       daysText(widestHours) +
       ". A Custom View can show more blocking and deadlock history.",
-    reachReads: [
-      "get_blocked_process_xml", "get_blocking", "get_blocking_stats", "get_blocking_trend",
-      "get_current_waits_trend", "get_deadlock_detail", "get_deadlock_trend", "get_deadlocks",
-      "get_lock_wait_trend"
-    ],
     build: (server, ctx) => [
       line("Blocking Events", "get_blocking_trend", { server, hours: ctx.hours }, "trend", "time", COUNT_SERIES, {
         subtitle: ctx.label,
@@ -1472,10 +1449,6 @@ export const SERVER_TABS = [
   {
     id: "io",
     label: "File I/O",
-    collector: "file_io_stats",
-    reachReads: [
-      "get_file_io_trend", "get_tempdb_trend"
-    ],
     build: (server, ctx) => [
       fileIoPanel(server, ctx),
       table(
@@ -1530,17 +1503,10 @@ export const SERVER_TABS = [
   {
     id: "queries",
     label: "Queries",
-    collector: "query_stats",
     note:
       "Execution-plan analysis, the query heatmap, cached-plan retrieval and actual-plan re-execution are " +
       "desktop-viewer features — they need a plan renderer and a command back to the monitored server, neither " +
       "of which this read-only web seat has.",
-    reachReads: [
-      "get_active_queries", "get_long_query_completions", "get_plan_corrections", "get_procedure_duration_trend",
-      "get_query_duration_trend", "get_query_heatmap", "get_query_store_clutter",
-      "get_query_store_duration_trend", "get_query_store_regressions", "get_query_store_top", "get_query_trend",
-      "get_top_procedures_by_cpu", "get_top_queries_by_cpu"
-    ],
     build: (server, ctx) => [
       activeQueriesPanel(server, ctx),
       /* #2484: the viewer's Performance Trends tab is four charts over three reads. Duration and the
@@ -1824,9 +1790,6 @@ export const SERVER_TABS = [
   {
     id: "changes",
     label: "Config Changes",
-    reachReads: [
-      "get_database_config_changes", "get_server_config_changes", "get_trace_flag_changes"
-    ],
     build: (server, ctx) => [
       table(
         "Server Configuration Changes",
@@ -1861,9 +1824,6 @@ export const SERVER_TABS = [
   {
     id: "activity",
     label: "Activity",
-    reachReads: [
-      "get_job_history", "get_perfmon_trend", "get_server_trend"
-    ],
     build: (server, ctx) => [
       perfmonPanel(server, ctx),
       sessionStatsTrendPanel(server, ctx),
@@ -1914,12 +1874,6 @@ export const SERVER_TABS = [
     note:
       "These are the system_health session and default trace, parsed on read. The desktop viewer additionally " +
       "charts the corruption and contention counters hour-by-hour; here they are the raw parsed rows.",
-    reachReads: [
-      "get_default_trace_events", "get_health_parser_cpu_tasks", "get_health_parser_io_issues",
-      "get_health_parser_memory_broker", "get_health_parser_memory_conditions",
-      "get_health_parser_memory_node_oom", "get_health_parser_scheduler_issues",
-      "get_health_parser_severe_errors", "get_health_parser_significant_waits", "get_health_parser_system_health"
-    ],
     build: (server, ctx) => [
       ...fanout("get_health_parser_system_health", { server, hours: ctx.hours, limit: 50 }, [
         {
@@ -2034,9 +1988,6 @@ export const SERVER_TABS = [
   {
     id: "health",
     label: "Collection Health",
-    reachReads: [
-      "get_collection_log"
-    ],
     build: (server, ctx) => [
       /* One read, three panels. get_collection_health rolls up seven days of collector logs AND computes sweep
          pressure; these are three slices of that single payload, so three descriptors meant running the tab's
@@ -2118,10 +2069,6 @@ export const POSTGRES_TABS = [
   {
     id: "overview",
     label: "Overview",
-    reachReads: [
-      "get_analysis_findings", "get_collection_log", "get_pg_autovacuum_health", "get_pg_cpu_utilization",
-      "get_pg_extensions", "get_pg_replication_slots", "get_pg_wraparound_risk", "get_pg_xmin_horizon"
-    ],
     build: (server, ctx) => [
       /* The vitals are the three Tier 0 outage predictors plus the backlog that feeds two of them, as tiles
          rather than the tables the owning tabs carry: the question on a triage screen is "is anything wrong",
@@ -2293,11 +2240,6 @@ export const POSTGRES_TABS = [
       "not: it comes from Amazon Aurora's aurora_stat_statements(), which core PostgreSQL has in no version, " +
       "so on a stock PostgreSQL target that one panel is permanently empty and says so in its own words " +
       "while the two above it keep working.",
-    reachReads: [
-      "get_pg_blocking", "get_pg_column_stats", "get_pg_database_stats", "get_pg_database_trend",
-      "get_pg_deadlocks", "get_pg_lock_stats", "get_pg_log_events", "get_pg_plan_capture_readiness",
-      "get_pg_plans", "get_pg_predicate_stats", "get_pg_query_duration_trend", "get_pg_top_queries"
-    ],
     build: (server, ctx) => [
       /* One read, three panels, and the FIRST of them is the denominator. get_pg_blocking is a periodic SAMPLE,
          not an event log: PostgreSQL records nothing unless asked, so "no chains" is ambiguous between a quiet
@@ -2534,9 +2476,6 @@ export const POSTGRES_TABS = [
       "which is where the fix has to be made, and only it says whether that session pins anything at all: an " +
       "open transaction holding no snapshot and no transaction id costs vacuum nothing, however long it has " +
       "been idle.",
-    reachReads: [
-      "get_pg_autovacuum_health", "get_pg_session_states", "get_pg_wraparound_risk", "get_pg_xmin_horizon"
-    ],
     build: (server, ctx) => [
       /* Ordered by CAUSE, not by severity: session, then horizon, then backlog, then headroom.
 
@@ -2643,7 +2582,6 @@ export const POSTGRES_TABS = [
   {
     id: "waits",
     label: "Waits",
-    collector: "pg_wait_sampling",
     /* THE DECISION, argued in the PR: this tab is SHOWN at every PostgreSQL target, including the stock ones
        where its read can never have content. get_pg_wait_stats reads aurora_stat_system_waits(), which core
        PostgreSQL has in no version, so on `postgres` the panel is permanently empty — and it is permanently
@@ -2658,9 +2596,6 @@ export const POSTGRES_TABS = [
       "aurora_stat_system_waits(), which core PostgreSQL has in no version. On a stock PostgreSQL target this " +
       "tab is permanently empty and the panel says so in its own words. The tab is here anyway so that the tab " +
       "set does not change shape between two PostgreSQL servers in the same fleet.",
-    reachReads: [
-      "get_pg_kernel_stats", "get_pg_wait_sampling", "get_pg_wait_stats", "get_pg_wait_trend"
-    ],
     build: (server, ctx) => [
       table(
         "Wait Events",
@@ -2719,15 +2654,11 @@ export const POSTGRES_TABS = [
   {
     id: "io",
     label: "I/O",
-    collector: "pg_io_stats",
     note:
       "PostgreSQL reports I/O by BACKEND TYPE, object and context rather than by file, so there is no " +
       "per-file grid here and the shape is deliberately not the SQL Server one. On Aurora the whole write side " +
       "is NULL — backends there do not write data files, storage does — so the write columns read as blank " +
       "rather than as zero, which would claim a measurement never taken.",
-    reachReads: [
-      "get_pg_buffer_usage", "get_pg_io_stats", "get_pg_io_trend", "get_pg_write_stats"
-    ],
     build: (server, ctx) => [
       ...fanout("get_pg_io_stats", { server, hours: ctx.hours, limit: 20 }, [
         {
@@ -2791,9 +2722,6 @@ export const POSTGRES_TABS = [
   {
     id: "replication",
     label: "Replication",
-    reachReads: [
-      "get_pg_replication_slots", "get_pg_replication_stats"
-    ],
     build: (server, ctx) => [
       ...fanout("get_pg_replication_slots", { server, hours: ctx.hours }, [
         {
@@ -2840,9 +2768,6 @@ export const POSTGRES_TABS = [
   {
     id: "storage",
     label: "Storage",
-    reachReads: [
-      "get_pg_index_bloat", "get_pg_index_usage", "get_pg_table_bloat"
-    ],
     build: (server, ctx) => [
       ...fanout("get_pg_table_bloat", { server, hours: ctx.hours, limit: 25 }, [
         {
@@ -2947,9 +2872,6 @@ export const POSTGRES_TABS = [
   {
     id: "config",
     label: "Configuration",
-    reachReads: [
-      "get_pg_server_config_changes"
-    ],
     build: (server, ctx) => [
       table(
         "Configuration Changes",
@@ -2973,6 +2895,11 @@ export const POSTGRES_TABS = [
   },
 ];
 
+/* Each tab's `reachReads` and `collector`, from server-tab-reach.js (#5562 r3): kept apart so a pin that counts a tab's fetches or
+   reads its neighbouring fields as text never sees a reach list. The tab objects carry both at run time. */
+withTabReach(SERVER_TABS, SQL_TAB_REACH);
+withTabReach(POSTGRES_TABS, POSTGRES_TAB_REACH);
+
 /**
  * The tab registry for a fleet card — the ONE place the engine branch lives.
  *

From b92e3ed6f9469f36243f6796323166defa72ac08 Mon Sep 17 00:00:00 2001
From: Erik Darling <2136037+erikdarlingdata@users.noreply.github.com>
Date: Thu, 8 Oct 2026 16:59:03 -0400
Subject: [PATCH 33/33] The seven guided tools keep their own routing detail
 first in the guide tail, with the reach sentence right after it (#5562)

---
 .../Mcp/DarlingMcpAlertTools.cs                             | 2 +-
 .../Mcp/DarlingMcpPgCpuUtilizationTools.cs                  | 2 +-
 .../Mcp/DarlingMcpPgTrendTools.cs                           | 4 ++--
 .../Mcp/DarlingMcpTrendTools.cs                             | 6 +++---
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
index 82d86c8ebd..5172dbd383 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpAlertTools.cs
@@ -76,7 +76,7 @@ namespace PerformanceMonitor.Darling.Service.Mcp;
 [McpServerToolType]
 public sealed class DarlingMcpAlertTools
 {
-    [McpServerTool(Name = "get_alert_history"), Description("Gets alert history, NEWEST FIRST: each row FIRED; notification_type says whether it was DELIVERED, a separate question from DISMISSED (UI-acknowledged), excluded by default. THE PAGE IS BOUNDED BY limit, NOT hours_back: truncated says the window held more, and oldest/newest_returned_alert_time bound how far the page reached. An EMPTY page can mean no alerts fired, or that every alert here was dismissed: dismissed_excluded_count says which; include_dismissed = true returns them, labelled dismissed = true. A null send_error proves nothing about delivery.<<GUIDE>> hours_back reaches 2160 (90 days, the alert table's retention). Gets recent alert history from the alert log, NEWEST FIRST: what alerts fired, when, for which server, the current vs threshold value, whether email/webhook delivery succeeded, and whether the alert was muted. Omit server_name to see the whole fleet (each row names its server); pass one to scope to a single server. THE PAGE IS BOUNDED BY limit, NOT BY hours_back: alerts_returned is how many rows you got, truncated says the window held more than limit, and oldest_returned_alert_time / newest_returned_alert_time bound the page — under newest-first ordering the oldest stamp IS how far back this read reached, so on a noisy fleet a 24-hour request at the default limit may cover minutes. Raise limit or narrow hours_back when truncated is true; widening hours_back cannot help. BY DEFAULT THIS READ EXCLUDES DISMISSED ALERTS — rows an operator acknowledged in the Viewer's Alert History grid. Dismissal says nothing about whether the alert fired or mattered, so an incident reconstruction that ignores it can miss the very critical someone already looked at: dismissed_excluded says whether the filter applied and dismissed_excluded_count is how many rows in the window it removed, and include_dismissed = true returns them, each labelled dismissed = true. notification_type is the delivery disposition and is the ONLY field that says why a row did not deliver: 'email'/'webhook'/'email+webhook' delivered on that channel; 'throttled' means the delivery cooldown was still inside this alert's window so nothing was attempted (the throttle working, not a fault); 'folded' means a repeat was rolled onto another server's post for the same metric and is named there under 'Other Servers Affected', so it WAS reported; 'failed' means a channel was attempted and came back unsuccessful, with send_error carrying the first failing channel's text; 'unconfigured' means no email or webhook channel is set up; 'muted' means a mute rule suppressed it; 'digest' means the analysis finding was UNCORROBORATED (one fact in its chain, no matched co-fire check) and the corroboration gate routed it to the daily Analysis Singles Digest and the web/MCP surfaces instead of a paging channel — nothing was attempted, nothing was suppressed, and routing_reason on the row says which components decided; 'none' is a resolution row, which no channel applies to. Do NOT split the not-delivered rows on send_error: it is null on 'throttled', 'folded' and 'digest' rows and on every row written before those values existed, so a null error is not evidence of a working cooldown. 'undelivered' is a retained legacy value that means throttled OR folded OR failed with nothing in the row to say which — count those rows separately rather than attributing them. severity is the row's tier — 'critical', 'warning', 'info' or 'resolution' — and severity_source says where it came from: 'fired' when the row persisted the tier the alert actually fired at (graded alerts such as Poison Wait, Volume Free Space and Database State fire Warning OR Critical by measurement), 'metric_name' when the row carries no tier and the metric's name is the only evidence (rows written before the tier was persisted, alerts whose severity is fixed per metric, and every resolution row). Do not infer a graded alert's tier from its name: a 'Poison Wait' row with severity 'warning' fired as a warning. route says WHERE the posts went: the alert's family (self-monitor / reports / agent-jobs / performance), the notification route that matched it (route_id null = the parent channels in Settings > Notifications answered everything) and each delivered channel with the route that supplied its destination — see get_notification_routes for the taxonomy and the routes. route is null on rows written before routing existed and on rows that never reached a delivery decision (throttled, folded, muted, unconfigured, digest, resolutions), so a null route is not evidence of a routing fault. routing is a DIFFERENT question from route: for an 'Analysis: …' finding it is the corroboration gate's decision one step UPSTREAM of the fan-out — 'page' when the finding earned a channel (two or more facts in its chain, or a matched co-fire check, or one of the two by-construction stories) and 'digest' when it was a lone uncorroborated fact — with routing_reason naming the components the gate read, so 'why didn't this page' is answered by the row. Both are null on every engine alert and on analysis rows written before the gate existed. To see what the digest carried, read the rows with notification_type 'digest' in the window: each is a persisted finding with its full detail_text and context, findable in get_analysis_findings by the story hash in its metric_name. Dismissal is an acknowledgement, not a verdict — a dismissed critical still fired — so set this when reconstructing an incident rather than triaging what is still open. Each row then carries dismissed so the two populations stay distinguishable.")]
+    [McpServerTool(Name = "get_alert_history"), Description("Gets alert history, NEWEST FIRST: each row FIRED; notification_type says whether it was DELIVERED, a separate question from DISMISSED (UI-acknowledged), excluded by default. THE PAGE IS BOUNDED BY limit, NOT hours_back: truncated says the window held more, and oldest/newest_returned_alert_time bound how far the page reached. An EMPTY page can mean no alerts fired, or that every alert here was dismissed: dismissed_excluded_count says which; include_dismissed = true returns them, labelled dismissed = true. A null send_error proves nothing about delivery.<<GUIDE>> Gets recent alert history from the alert log, NEWEST FIRST: what alerts fired, when, for which server, the current vs threshold value, whether email/webhook delivery succeeded, and whether the alert was muted. hours_back reaches 2160 (90 days, the alert table's retention). Omit server_name to see the whole fleet (each row names its server); pass one to scope to a single server. THE PAGE IS BOUNDED BY limit, NOT BY hours_back: alerts_returned is how many rows you got, truncated says the window held more than limit, and oldest_returned_alert_time / newest_returned_alert_time bound the page — under newest-first ordering the oldest stamp IS how far back this read reached, so on a noisy fleet a 24-hour request at the default limit may cover minutes. Raise limit or narrow hours_back when truncated is true; widening hours_back cannot help. BY DEFAULT THIS READ EXCLUDES DISMISSED ALERTS — rows an operator acknowledged in the Viewer's Alert History grid. Dismissal says nothing about whether the alert fired or mattered, so an incident reconstruction that ignores it can miss the very critical someone already looked at: dismissed_excluded says whether the filter applied and dismissed_excluded_count is how many rows in the window it removed, and include_dismissed = true returns them, each labelled dismissed = true. notification_type is the delivery disposition and is the ONLY field that says why a row did not deliver: 'email'/'webhook'/'email+webhook' delivered on that channel; 'throttled' means the delivery cooldown was still inside this alert's window so nothing was attempted (the throttle working, not a fault); 'folded' means a repeat was rolled onto another server's post for the same metric and is named there under 'Other Servers Affected', so it WAS reported; 'failed' means a channel was attempted and came back unsuccessful, with send_error carrying the first failing channel's text; 'unconfigured' means no email or webhook channel is set up; 'muted' means a mute rule suppressed it; 'digest' means the analysis finding was UNCORROBORATED (one fact in its chain, no matched co-fire check) and the corroboration gate routed it to the daily Analysis Singles Digest and the web/MCP surfaces instead of a paging channel — nothing was attempted, nothing was suppressed, and routing_reason on the row says which components decided; 'none' is a resolution row, which no channel applies to. Do NOT split the not-delivered rows on send_error: it is null on 'throttled', 'folded' and 'digest' rows and on every row written before those values existed, so a null error is not evidence of a working cooldown. 'undelivered' is a retained legacy value that means throttled OR folded OR failed with nothing in the row to say which — count those rows separately rather than attributing them. severity is the row's tier — 'critical', 'warning', 'info' or 'resolution' — and severity_source says where it came from: 'fired' when the row persisted the tier the alert actually fired at (graded alerts such as Poison Wait, Volume Free Space and Database State fire Warning OR Critical by measurement), 'metric_name' when the row carries no tier and the metric's name is the only evidence (rows written before the tier was persisted, alerts whose severity is fixed per metric, and every resolution row). Do not infer a graded alert's tier from its name: a 'Poison Wait' row with severity 'warning' fired as a warning. route says WHERE the posts went: the alert's family (self-monitor / reports / agent-jobs / performance), the notification route that matched it (route_id null = the parent channels in Settings > Notifications answered everything) and each delivered channel with the route that supplied its destination — see get_notification_routes for the taxonomy and the routes. route is null on rows written before routing existed and on rows that never reached a delivery decision (throttled, folded, muted, unconfigured, digest, resolutions), so a null route is not evidence of a routing fault. routing is a DIFFERENT question from route: for an 'Analysis: …' finding it is the corroboration gate's decision one step UPSTREAM of the fan-out — 'page' when the finding earned a channel (two or more facts in its chain, or a matched co-fire check, or one of the two by-construction stories) and 'digest' when it was a lone uncorroborated fact — with routing_reason naming the components the gate read, so 'why didn't this page' is answered by the row. Both are null on every engine alert and on analysis rows written before the gate existed. To see what the digest carried, read the rows with notification_type 'digest' in the window: each is a persisted finding with its full detail_text and context, findable in get_analysis_findings by the story hash in its metric_name. Dismissal is an acknowledgement, not a verdict — a dismissed critical still fired — so set this when reconstructing an incident rather than triaging what is still open. Each row then carries dismissed so the two populations stay distinguishable.")]
     public static async Task<string> GetAlertHistory(
         NpgsqlDataSource postgres,
         [Description("Server name or display name. Omit to return alerts across all servers (the fleet default).")] string? server_name = null,
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
index 38d1a21dd4..44f6483621 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgCpuUtilizationTools.cs
@@ -44,7 +44,7 @@ namespace PerformanceMonitor.Darling.Service.Mcp;
 [McpServerToolType]
 public sealed class DarlingMcpPgCpuUtilizationTools
 {
-    [McpServerTool(Name = "get_pg_cpu_utilization"), Description("Gets instance-level CPU for a PostgreSQL/Aurora target from AWS Performance Insights, in time buckets (bucket_minutes) to as_of. Aurora only; RDS and self-hosted are not_collected. cpu_percent is percent of capacity CURRENTLY ALLOCATED, not a fixed ceiling - on Serverless v2 that moves, so 100% is often a scale-up, not saturation. acu_utilization_percent is percent of the CONFIGURED ceiling, the saturation figure; null ACU means no sample, never headroom. Host-memory bytes (since V136) are null when unmeasured; memory_samples_in_bucket is the count. <<GUIDE>> hours_back reaches 720 (30 days). Gets instance-level CPU utilization over time for a PostgreSQL/Aurora target, from AWS Performance Insights, bucketed to a point budget the same way get_cpu_utilization is (#4193, the #3897 TrendBuckets contract) rather than one row per raw 1-minute sample. Aurora only - a plain RDS or self-hosted target has no route here and this is not_collected for it; Performance Insights could reach plain RDS too, but no monitored target is that shape yet. cpu_percent is os.cpuUtilization.total.avg, which is percent of the capacity CURRENTLY ALLOCATED: on Aurora Serverless v2 that allocation moves, so 100% is routinely a scale-up rather than saturation. acu_utilization_percent (os.general.acuUtilization.avg) is percent of the CONFIGURED ACU ceiling and is the saturation figure - band and alert on that one. Both are reported per bucket as the AVERAGE of the bucket's samples, with peak_cpu_percent/peak_acu_utilization_percent holding the single busiest sample, so a saturation minute is never averaged away by a wide bucket; a null ACU figure means no capacity sample in that bucket, never headroom. Since V136 the same row carries the HOST'S MEMORY from Performance Insights' os.memory.* counters, in bytes: memory_total_bytes, memory_cached_bytes, memory_buffers_bytes and configured_memory_bytes are the bucket's average; memory_free_bytes and memory_active_bytes are its WORST sample (minimum free, maximum active) rather than an average, so a brief pressure spike survives a wide bucket - the figures the PG_HOST_MEMORY_PRESSURE and CONFIG_PG_MEMORY_OVERCOMMIT facts are measured against (get_analysis_facts source=pg_memory). Every memory figure is null on a pre-V136 row or an endpoint without os.memory.*, and null means not measured, never zero memory; memory_samples_in_bucket says how many samples carried it.")]
+    [McpServerTool(Name = "get_pg_cpu_utilization"), Description("Gets instance-level CPU for a PostgreSQL/Aurora target from AWS Performance Insights, in time buckets (bucket_minutes) to as_of. Aurora only; RDS and self-hosted are not_collected. cpu_percent is percent of capacity CURRENTLY ALLOCATED, not a fixed ceiling - on Serverless v2 that moves, so 100% is often a scale-up, not saturation. acu_utilization_percent is percent of the CONFIGURED ceiling, the saturation figure; null ACU means no sample, never headroom. Host-memory bytes (since V136) are null when unmeasured; memory_samples_in_bucket is the count. <<GUIDE>> Gets instance-level CPU utilization over time for a PostgreSQL/Aurora target, from AWS Performance Insights, bucketed to a point budget the same way get_cpu_utilization is (#4193, the #3897 TrendBuckets contract) rather than one row per raw 1-minute sample. hours_back reaches 720 (30 days). Aurora only - a plain RDS or self-hosted target has no route here and this is not_collected for it; Performance Insights could reach plain RDS too, but no monitored target is that shape yet. cpu_percent is os.cpuUtilization.total.avg, which is percent of the capacity CURRENTLY ALLOCATED: on Aurora Serverless v2 that allocation moves, so 100% is routinely a scale-up rather than saturation. acu_utilization_percent (os.general.acuUtilization.avg) is percent of the CONFIGURED ACU ceiling and is the saturation figure - band and alert on that one. Both are reported per bucket as the AVERAGE of the bucket's samples, with peak_cpu_percent/peak_acu_utilization_percent holding the single busiest sample, so a saturation minute is never averaged away by a wide bucket; a null ACU figure means no capacity sample in that bucket, never headroom. Since V136 the same row carries the HOST'S MEMORY from Performance Insights' os.memory.* counters, in bytes: memory_total_bytes, memory_cached_bytes, memory_buffers_bytes and configured_memory_bytes are the bucket's average; memory_free_bytes and memory_active_bytes are its WORST sample (minimum free, maximum active) rather than an average, so a brief pressure spike survives a wide bucket - the figures the PG_HOST_MEMORY_PRESSURE and CONFIG_PG_MEMORY_OVERCOMMIT facts are measured against (get_analysis_facts source=pg_memory). Every memory figure is null on a pre-V136 row or an endpoint without os.memory.*, and null means not measured, never zero memory; memory_samples_in_bucket says how many samples carried it.")]
     public static Task<string> GetPgCpuUtilization(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
index ddf36e9bd0..74c2625844 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpPgTrendTools.cs
@@ -255,7 +255,7 @@ statement that does not exist. */
         }
     }
 
-    [McpServerTool(Name = "get_pg_io_trend"), Description("Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io: read/write/extend rates per second, cache-hit ratio, per-op latency, bucketed to as_of. Requires PostgreSQL 16+. avg_read_ms/avg_write_ms are null, never 0.000, when track_io_timing is off. Write fields are null, not 0, on Amazon Aurora (no write counters). Byte rates: measured (18+), estimated (earlier), or null. Empty: no pair was active, or the window holds one snapshot (a trend needs two to difference). A point spanning a stats reset reports everything since the reset, not a quiet interval. <<GUIDE>> hours_back reaches 720 (30 days). Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io, in time buckets: read, write and extend rates per second, the buffer-cache hit ratio for each point, and per-operation latency where the server measures it. Use get_pg_io_stats first to see which combinations are busy, then this to see whether one is growing or slowing. The subject is a PAIR because a hit ratio summed across contexts is meaningless - bulkread is a sequential scan deliberately bypassing the buffer pool with a ring buffer, so averaging its misses with the normal context's understates both and they have opposite remedies. Object types are summed together, which cannot distort the ratio because WAL rows report no buffer hits. Reports whether the server tracks I/O TIMING at all: track_io_timing is OFF by default in PostgreSQL, and its zero read_time would otherwise divide out to a latency of 0.000 ms that reads as an impossibly fast disk rather than an unmeasured one. Also reports whether byte volumes are MEASURED (PostgreSQL 18's read_bytes/write_bytes) or ESTIMATED as operations x block size (pre-18) - the two are different quantities and 18 moves several blocks per operation, so the older estimate undercounts there. Write counters are null rather than zero on Amazon Aurora, where backends do not write data files. A point holding an interval that spans a pg_stat_reset_shared('io') or a restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Requires PostgreSQL 16 or later; valid on a standby. On backend_type: Naming this alone follows the busiest CONTEXT for that backend; omit both to follow whichever pair moved the most I/O.")]
+    [McpServerTool(Name = "get_pg_io_trend"), Description("Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io: read/write/extend rates per second, cache-hit ratio, per-op latency, bucketed to as_of. Requires PostgreSQL 16+. avg_read_ms/avg_write_ms are null, never 0.000, when track_io_timing is off. Write fields are null, not 0, on Amazon Aurora (no write counters). Byte rates: measured (18+), estimated (earlier), or null. Empty: no pair was active, or the window holds one snapshot (a trend needs two to difference). A point spanning a stats reset reports everything since the reset, not a quiet interval. <<GUIDE>> Gets a time series for ONE PostgreSQL (backend_type, context) pair from pg_stat_io, in time buckets: read, write and extend rates per second, the buffer-cache hit ratio for each point, and per-operation latency where the server measures it. hours_back reaches 720 (30 days). Use get_pg_io_stats first to see which combinations are busy, then this to see whether one is growing or slowing. The subject is a PAIR because a hit ratio summed across contexts is meaningless - bulkread is a sequential scan deliberately bypassing the buffer pool with a ring buffer, so averaging its misses with the normal context's understates both and they have opposite remedies. Object types are summed together, which cannot distort the ratio because WAL rows report no buffer hits. Reports whether the server tracks I/O TIMING at all: track_io_timing is OFF by default in PostgreSQL, and its zero read_time would otherwise divide out to a latency of 0.000 ms that reads as an impossibly fast disk rather than an unmeasured one. Also reports whether byte volumes are MEASURED (PostgreSQL 18's read_bytes/write_bytes) or ESTIMATED as operations x block size (pre-18) - the two are different quantities and 18 moves several blocks per operation, so the older estimate undercounts there. Write counters are null rather than zero on Amazon Aurora, where backends do not write data files. A point holding an interval that spans a pg_stat_reset_shared('io') or a restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Requires PostgreSQL 16 or later; valid on a standby. On backend_type: Naming this alone follows the busiest CONTEXT for that backend; omit both to follow whichever pair moved the most I/O.")]
     public static Task<string> GetPgIoTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
@@ -519,7 +519,7 @@ survives the bucket. The latency peak is nulled on the same rule as avg_read_ms.
         }
     }
 
-    [McpServerTool(Name = "get_pg_database_trend"), Description("Gets a time series for ONE PostgreSQL database from pg_stat_database: temp-file spills, cache-hit ratio, deadlocks and rollback share, bucketed to as_of. Differenced per interval - the raw counters are cumulative, and a real cliff averages out otherwise. cache_hit_pct/rollback_pct are null, not 0, on an interval with no accesses or no completed transactions. deadlocks is a COUNT per point, not a rate. A point spanning a stats reset reports everything since, never a quiet interval. Empty: wrong name, only one snapshot so far, or none in the window - the message says which. <<GUIDE>> hours_back reaches 720 (30 days). Gets a time series for ONE PostgreSQL database from pg_stat_database, in time buckets: temp-file spills, the buffer-cache hit ratio (with each bucket's worst interval), deadlocks and the rollback share. This is where the cache hit ratio becomes usable at all - pg_stat_database's counters are cumulative since the last reset, so the ratio computed from them raw is a lifetime average that barely moves, and a database that fell off a cliff an hour ago still reports 99% because of the weeks behind it. Differenced per interval, the cliff is visible. Temp files are the same story: 'this database spilled 40 GB this week' does not say whether it was one bad afternoon or a steady leak, and the two have different fixes. Deadlocks are reported as a COUNT per point rather than a rate, because they are discrete server-recorded events. Omit database to follow the biggest temp-file spiller. PostgreSQL's shared-relations row - the cluster-wide catalog, which has a NULL database name - is followable by passing '(shared relations)' but is never chosen automatically. A point holding an interval that spans a pg_stat_reset or a crash restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Works on every PostgreSQL major and on a standby, where sorts spill exactly the way they do on a writer.")]
+    [McpServerTool(Name = "get_pg_database_trend"), Description("Gets a time series for ONE PostgreSQL database from pg_stat_database: temp-file spills, cache-hit ratio, deadlocks and rollback share, bucketed to as_of. Differenced per interval - the raw counters are cumulative, and a real cliff averages out otherwise. cache_hit_pct/rollback_pct are null, not 0, on an interval with no accesses or no completed transactions. deadlocks is a COUNT per point, not a rate. A point spanning a stats reset reports everything since, never a quiet interval. Empty: wrong name, only one snapshot so far, or none in the window - the message says which. <<GUIDE>> Gets a time series for ONE PostgreSQL database from pg_stat_database, in time buckets: temp-file spills, the buffer-cache hit ratio (with each bucket's worst interval), deadlocks and the rollback share. hours_back reaches 720 (30 days). This is where the cache hit ratio becomes usable at all - pg_stat_database's counters are cumulative since the last reset, so the ratio computed from them raw is a lifetime average that barely moves, and a database that fell off a cliff an hour ago still reports 99% because of the weeks behind it. Differenced per interval, the cliff is visible. Temp files are the same story: 'this database spilled 40 GB this week' does not say whether it was one bad afternoon or a steady leak, and the two have different fixes. Deadlocks are reported as a COUNT per point rather than a rate, because they are discrete server-recorded events. Omit database to follow the biggest temp-file spiller. PostgreSQL's shared-relations row - the cluster-wide catalog, which has a NULL database name - is followable by passing '(shared relations)' but is never chosen automatically. A point holding an interval that spans a pg_stat_reset or a crash restart is flagged and reports everything since the reset, rather than the quiet interval that clamping the difference at zero would show. Works on every PostgreSQL major and on a standby, where sorts spill exactly the way they do on a writer.")]
     public static Task<string> GetPgDatabaseTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
diff --git a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
index 7cf577e6db..0d66783410 100644
--- a/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
+++ b/Darling/PerformanceMonitor.Darling.Service/Mcp/DarlingMcpTrendTools.cs
@@ -498,7 +498,7 @@ want opposite remedies — see the class remarks and McpHelpers.WindowTruncatedD
         }
     }
 
-    [McpServerTool(Name = "get_query_duration_trend"), Description("Gets a time-series of query elapsed_ms_per_second and executions_per_second across all queries, points ending at as_of. A collection whose interval was unknowable is excluded, not counted as 0: unrated_collections counts it, and a point left with nothing else carries null rates (unrated_points), never zero. No points: unavailable means query_stats was never collected here; empty means it was (the message says quiet window or rollup coverage gap). window_truncated is the store's retention floor, not a page cut: effective_start / effective_hours_back say where the answer begins. <<GUIDE>> hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Gets a time-series of average query duration over time. Useful for spotting overall performance degradation or improvement trends across all queries. Points are time buckets (bucket, aggregate_note); rates are over each collection's STORED sample interval, and a collection whose interval was unknowable - a restart or counter reset, or the window's first collection when none was stored - is left out rather than counted as 0 (unrated_collections counts them; a point with nothing else carries null rates, unrated_points). The hourly rollup route divides by the bucket width and has no unrated point." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
+    [McpServerTool(Name = "get_query_duration_trend"), Description("Gets a time-series of query elapsed_ms_per_second and executions_per_second across all queries, points ending at as_of. A collection whose interval was unknowable is excluded, not counted as 0: unrated_collections counts it, and a point left with nothing else carries null rates (unrated_points), never zero. No points: unavailable means query_stats was never collected here; empty means it was (the message says quiet window or rollup coverage gap). window_truncated is the store's retention floor, not a page cut: effective_start / effective_hours_back say where the answer begins. <<GUIDE>> Gets a time-series of average query duration over time. hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Useful for spotting overall performance degradation or improvement trends across all queries. Points are time buckets (bucket, aggregate_note); rates are over each collection's STORED sample interval, and a collection whose interval was unknowable - a restart or counter reset, or the window's first collection when none was stored - is left out rather than counted as 0 (unrated_collections counts them; a point with nothing else carries null rates, unrated_points). The hourly rollup route divides by the bucket width and has no unrated point." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
     public static Task<string> GetQueryDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
@@ -598,7 +598,7 @@ is not a server nothing was ever stored for. */
         }
     }
 
-    [McpServerTool(Name = "get_procedure_duration_trend"), Description("Gets a time-series of stored-procedure elapsed_ms_per_second and executions_per_second, summed across every procedure and charged to the whole call rather than smeared across its statements the way query_stats attributes work. Points end at as_of. unrated_points, unrated_collections, the empty/unavailable split and window_truncated (a retention floor, not a page cut) all follow get_query_duration_trend exactly. <<GUIDE>> hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Gets a time-series of stored-procedure elapsed time per second and executions per second over time, summed across every procedure. The sibling of get_query_duration_trend, and NOT a duplicate of it: query_stats attributes a procedure's work to the individual statements inside it, so a procedure that got slower is smeared across however many statements it runs. This charges the whole call to the procedure. Read the two together to tell an ad-hoc SQL regression from a procedure regression. Points, rates and unrated collections (unrated_points, unrated_collections) follow get_query_duration_trend exactly." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
+    [McpServerTool(Name = "get_procedure_duration_trend"), Description("Gets a time-series of stored-procedure elapsed_ms_per_second and executions_per_second, summed across every procedure and charged to the whole call rather than smeared across its statements the way query_stats attributes work. Points end at as_of. unrated_points, unrated_collections, the empty/unavailable split and window_truncated (a retention floor, not a page cut) all follow get_query_duration_trend exactly. <<GUIDE>> Gets a time-series of stored-procedure elapsed time per second and executions per second over time, summed across every procedure. hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. The sibling of get_query_duration_trend, and NOT a duplicate of it: query_stats attributes a procedure's work to the individual statements inside it, so a procedure that got slower is smeared across however many statements it runs. This charges the whole call to the procedure. Read the two together to tell an ad-hoc SQL regression from a procedure regression. Points, rates and unrated collections (unrated_points, unrated_collections) follow get_query_duration_trend exactly." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
     public static Task<string> GetProcedureDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,
@@ -675,7 +675,7 @@ width rule on the hourly tier. */
         }
     }
 
-    [McpServerTool(Name = "get_query_store_duration_trend"), Description("Gets a time-series of Query Store duration and executions per second, summed across every query, each interval counted once, at the hour it ran. not_collected: engine cannot run Query Store. unavailable: never sampled here. empty: quiet on Lite always; on Darling, empty can also be a rollup coverage gap (window predates the corrected rollup, run --backfill-rollups). Only a point that stored no interval end and has no earlier point to rate against has null rates, never 0 (unrated_points, unrated_note says why). window_truncated marks the retention floor, not a page cut. <<GUIDE>> hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Gets a time-series of Query Store duration per second and executions per second over time, summed across every query. Where get_query_duration_trend reads the plan cache and loses everything an eviction or a restart takes with it, this reads Query Store, which persists per interval - so it is the series that survives a failover and the one to reach for when a regression is older than the cache. Each interval is counted once, at the hour the work ran. A rollup point (an hourly bucket the corrected rollup has materialized) is rated over its bucket width, so every rollup point is rated, the window's first bucket included; a raw point (a Query Store interval placed at its start, or a legacy row at its collection time) is rated over its own stored interval, its end minus its start. A raw point with no stored end (a row collected before the end was recorded, and every legacy row) falls back to the gap since the PREVIOUS point, so only such a point, when it is first in the window and has no previous one to difference against, carries null rates: unknowable, never reported as 0 (unrated_points counts them, unrated_note says why)." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
+    [McpServerTool(Name = "get_query_store_duration_trend"), Description("Gets a time-series of Query Store duration and executions per second, summed across every query, each interval counted once, at the hour it ran. not_collected: engine cannot run Query Store. unavailable: never sampled here. empty: quiet on Lite always; on Darling, empty can also be a rollup coverage gap (window predates the corrected rollup, run --backfill-rollups). Only a point that stored no interval end and has no earlier point to rate against has null rates, never 0 (unrated_points, unrated_note says why). window_truncated marks the retention floor, not a page cut. <<GUIDE>> Gets a time-series of Query Store duration per second and executions per second over time, summed across every query. hours_back reaches 2160 (90 days), served from the hourly rollup past the raw tier's four days. Where get_query_duration_trend reads the plan cache and loses everything an eviction or a restart takes with it, this reads Query Store, which persists per interval - so it is the series that survives a failover and the one to reach for when a regression is older than the cache. Each interval is counted once, at the hour the work ran. A rollup point (an hourly bucket the corrected rollup has materialized) is rated over its bucket width, so every rollup point is rated, the window's first bucket included; a raw point (a Query Store interval placed at its start, or a legacy row at its collection time) is rated over its own stored interval, its end minus its start. A raw point with no stored end (a row collected before the end was recorded, and every legacy row) falls back to the gap since the PREVIOUS point, so only such a point, when it is first in the window and has no previous one to difference against, carries null rates: unknowable, never reported as 0 (unrated_points counts them, unrated_note says why)." + McpHelpers.WindowTruncatedDescription + BaselineDiscontinuities.DescriptionSentence)]
     public static Task<string> GetQueryStoreDurationTrend(
         NpgsqlDataSource postgres,
         [Description("Server name or display name.")] string? server_name = null,