diff --git a/lib/compute/vendor_sleep.dart b/lib/compute/vendor_sleep.dart
index 7a95b8a23..a534a3b85 100644
--- a/lib/compute/vendor_sleep.dart
+++ b/lib/compute/vendor_sleep.dart
@@ -47,6 +47,27 @@ const String kOurRingNightSource = 'hr_5min_stager';
 /// ('auto_fallback'), not the device's.
 const String kHrWindowNightSource = 'hr_5min_window';
 
+/// The point list a night is drawn and read from: each epoch's stage from its
+/// start, closed by a final point at wake. A stretch no epoch covers gets an
+/// `unobserved` boundary where the epoch before it ends, so a reader of the
+/// list never carries that epoch's stage across the hole.
+List<Map<String, Object?>> vendorHypnogram(
+    List<VendorEpoch> epochs, int wakeSec) {
+  final out = <Map<String, Object?>>[];
+  for (var i = 0; i < epochs.length; i++) {
+    final e = epochs[i];
+    out.add({'t': e.startSec, 'stage': e.stage});
+    final next = i + 1 < epochs.length ? epochs[i + 1].startSec : wakeSec;
+    if (next > e.endSec) out.add({'t': e.endSec, 'stage': 'unobserved'});
+  }
+  final last = epochs.last;
+  out.add({
+    't': wakeSec,
+    'stage': last.endSec < wakeSec ? 'unobserved' : last.stage,
+  });
+  return out;
+}
+
 /// One night of one device's epochs, as `vendor_sleep_epoch` groups them.
 class VendorNight {
   final String deviceId;
diff --git a/lib/data/local_repository_impl.dart b/lib/data/local_repository_impl.dart
index 48c940df8..1c708a471 100644
--- a/lib/data/local_repository_impl.dart
+++ b/lib/data/local_repository_impl.dart
@@ -29,6 +29,7 @@ import '../compute/manual_session.dart';
 import '../compute/onehz_pipeline.dart' show kUnknownAbsenceNote, needInputNote;
 import '../compute/profile.dart';
 import '../compute/quiet_level.dart';
+import '../compute/vendor_sleep.dart' show vendorHypnogram;
 import 'package:openstrap_protocol/openstrap_protocol.dart' as proto;
 import 'package:openstrap_analytics/onehz.dart' as ana;
 
@@ -2334,10 +2335,7 @@ class LocalRepositoryImpl extends LocalRepository {
         'stage_min': minutes,
         // Same point shape as our own night: each stage from its start,
         // closed by a final point at wake.
-        'hypnogram': [
-          for (final e in n.epochs) {'t': e.startSec, 'stage': e.stage},
-          {'t': n.offsetSec, 'stage': n.epochs.last.stage},
-        ],
+        'hypnogram': vendorHypnogram(n.epochs, n.offsetSec),
       });
     }
     return out;
diff --git a/lib/l10n/app_de.arb b/lib/l10n/app_de.arb
index 233bed5aa..aa6000649 100644
--- a/lib/l10n/app_de.arb
+++ b/lib/l10n/app_de.arb
@@ -1176,6 +1176,10 @@
   "metricDetailSlotNoValueRecording": "{day}, kein Wert · {who}",
   "metricDetailSlotNothingRecording": "{day}, keine Aufzeichnung",
   "metricDetailOpenDay": "{day} öffnen",
+  "chartPanelLatest": "ZULETZT",
+  "chartPanelSelected": "AUSGEWÄHLT",
+  "chartPanelSevenDayAvg": "7-Tage-Schnitt",
+  "chartPanelVsAvg": "ggü. Schnitt",
   "metricDetailNoRecordLabel": "Kein Eintrag",
   "metricDetailLowest": "Niedrigster",
   "metricDetailTypical": "Typisch",
diff --git a/lib/l10n/app_en.arb b/lib/l10n/app_en.arb
index ec5231ef9..3add13a51 100644
--- a/lib/l10n/app_en.arb
+++ b/lib/l10n/app_en.arb
@@ -5680,6 +5680,22 @@
       }
     }
   },
+  "chartPanelLatest": "LATEST",
+  "@chartPanelLatest": {
+    "description": "Caption prefix on the panel under a chart when nothing is selected: the newest reading. Shown upper-case where the script has case. It is not a judgement such as best."
+  },
+  "chartPanelSelected": "SELECTED",
+  "@chartPanelSelected": {
+    "description": "Caption prefix on the panel under a chart while a finger is on the chart: the reading the finger is on."
+  },
+  "chartPanelSevenDayAvg": "7-day avg",
+  "@chartPanelSevenDayAvg": {
+    "description": "Metric-detail panel stat: the last 7 days up to today, the same figure whichever day is shown."
+  },
+  "chartPanelVsAvg": "vs avg",
+  "@chartPanelVsAvg": {
+    "description": "Metric-detail panel stat: the shown value minus that 7-day average."
+  },
   "metricDetailNoRecordLabel": "No record",
   "@metricDetailNoRecordLabel": {
     "description": "Value text shown in the touched-day row when that day has no record."
diff --git a/lib/l10n/app_es.arb b/lib/l10n/app_es.arb
index a236842ec..83eb37e74 100644
--- a/lib/l10n/app_es.arb
+++ b/lib/l10n/app_es.arb
@@ -1133,6 +1133,10 @@
   "metricDetailSlotNoRecord": "{day}, sin registro",
   "metricDetailSlotWithValue": "{day}, {value} {unit}",
   "metricDetailOpenDay": "Abrir {day}",
+  "chartPanelLatest": "ÚLTIMO",
+  "chartPanelSelected": "SELECCIONADO",
+  "chartPanelSevenDayAvg": "Media de 7 días",
+  "chartPanelVsAvg": "vs. media",
   "metricDetailNoRecordLabel": "Sin registro",
   "metricDetailLowest": "Mínimo",
   "metricDetailTypical": "Típico",
diff --git a/lib/l10n/app_fr.arb b/lib/l10n/app_fr.arb
index 2875f5709..b0a5ce712 100644
--- a/lib/l10n/app_fr.arb
+++ b/lib/l10n/app_fr.arb
@@ -1133,6 +1133,10 @@
   "metricDetailSlotNoRecord": "{day}, aucun enregistrement",
   "metricDetailSlotWithValue": "{day}, {value} {unit}",
   "metricDetailOpenDay": "Ouvrir {day}",
+  "chartPanelLatest": "DERNIER",
+  "chartPanelSelected": "SÉLECTIONNÉ",
+  "chartPanelSevenDayAvg": "Moy. sur 7 jours",
+  "chartPanelVsAvg": "vs moy.",
   "metricDetailNoRecordLabel": "Aucun enregistrement",
   "metricDetailLowest": "Minimum",
   "metricDetailTypical": "Typique",
diff --git a/lib/l10n/app_hi.arb b/lib/l10n/app_hi.arb
index b9fea6734..87445f536 100644
--- a/lib/l10n/app_hi.arb
+++ b/lib/l10n/app_hi.arb
@@ -1133,6 +1133,10 @@
   "metricDetailSlotNoRecord": "{day}, कोई रिकॉर्ड नहीं",
   "metricDetailSlotWithValue": "{day}, {value} {unit}",
   "metricDetailOpenDay": "{day} खोलें",
+  "chartPanelLatest": "नवीनतम",
+  "chartPanelSelected": "चुना गया",
+  "chartPanelSevenDayAvg": "7 दिन का औसत",
+  "chartPanelVsAvg": "औसत से अंतर",
   "metricDetailNoRecordLabel": "कोई रिकॉर्ड नहीं",
   "metricDetailLowest": "न्यूनतम",
   "metricDetailTypical": "सामान्य",
diff --git a/lib/l10n/app_ru.arb b/lib/l10n/app_ru.arb
index f25901a16..b78a34dd9 100644
--- a/lib/l10n/app_ru.arb
+++ b/lib/l10n/app_ru.arb
@@ -2507,6 +2507,10 @@
       }
     }
   },
+  "chartPanelLatest": "ПОСЛЕДНЕЕ",
+  "chartPanelSelected": "ВЫБРАНО",
+  "chartPanelSevenDayAvg": "Среднее за 7 дн.",
+  "chartPanelVsAvg": "от среднего",
   "metricDetailNoRecordLabel": "Нет записи",
   "metricDetailLowest": "Наименьшее",
   "metricDetailTypical": "Обычное",
diff --git a/lib/l10n/app_th.arb b/lib/l10n/app_th.arb
index 19e7265dd..7b51c6b4d 100644
--- a/lib/l10n/app_th.arb
+++ b/lib/l10n/app_th.arb
@@ -5668,6 +5668,10 @@
       }
     }
   },
+  "chartPanelLatest": "ล่าสุด",
+  "chartPanelSelected": "ที่เลือก",
+  "chartPanelSevenDayAvg": "ค่าเฉลี่ย 7 วัน",
+  "chartPanelVsAvg": "เทียบค่าเฉลี่ย",
   "metricDetailNoRecordLabel": "ไม่มีข้อมูลบันทึก",
   "@metricDetailNoRecordLabel": {
     "description": "Value text shown in the touched-day row when that day has no record."
diff --git a/lib/l10n/app_zh.arb b/lib/l10n/app_zh.arb
index 111dc74e2..c66c6cff0 100644
--- a/lib/l10n/app_zh.arb
+++ b/lib/l10n/app_zh.arb
@@ -1133,6 +1133,10 @@
   "metricDetailSlotNoRecord": "{day}，无记录",
   "metricDetailSlotWithValue": "{day}，{value} {unit}",
   "metricDetailOpenDay": "打开{day}",
+  "chartPanelLatest": "最新",
+  "chartPanelSelected": "已选",
+  "chartPanelSevenDayAvg": "7 天平均",
+  "chartPanelVsAvg": "与平均相比",
   "metricDetailNoRecordLabel": "无记录",
   "metricDetailLowest": "最低",
   "metricDetailTypical": "典型",
diff --git a/lib/ui2/README.md b/lib/ui2/README.md
index ae6e012e2..8174129f1 100644
--- a/lib/ui2/README.md
+++ b/lib/ui2/README.md
@@ -121,6 +121,53 @@ that did not exist.
 `Scrubber` is the only drag: it carries the slider role, so increase/decrease
 reach it without a pointer, and `describe` is what those steps say out loud.
 
+### ChartPanel — what a chart reads, always on screen
+
+```dart
+ChartPanel({required String? time, required bool scrubbed, required Color color,
+            required List<ChartPanelCell> cells, List<ChartPanelCell> stats = const [],
+            List<String> timeSpan = const [], VoidCallback? onOpen, String? openLabel})
+ChartPanelCell(String label, {Color? color, String? value, Color? valueColor})
+```
+
+Put it under a chart that has a `Scrubber`, in the same card. It is there at
+rest and while a finger is on the chart, so the chart never changes height under
+the thumb and nothing is readable only while it is held. There is no pop-in.
+
+- **Caption.** `LATEST · <time>` at rest (the newest reading, or on a night the
+  stage at wake), `SELECTED · <time>` while scrubbing. Neither is a judgement.
+  While scrubbing the caption and a 1.5 pt border take the series colour
+  (`p.on(...)`, so they clear 4.5:1 on `card2`); at rest there is no border.
+- **Box.** `card2` fill, `R.rMd`, no shadow, inset in the chart's card. Its rect
+  is the same at rest, scrubbing, on a gap and at any text size. The caption
+  reserves the height of the tallest of `timeSpan` (every time the panel can
+  show), measured once per span, width, scale and locale, so a day name that
+  wraps in one language cannot move the panel.
+- **Cells.** One per series, each its label and the value at that instant.
+  A series with nothing there reads `—`: never a neighbour's value, never an
+  interpolation. One cell is drawn large; several are equal width, one row when
+  they fit and wrapped when they do not.
+- **Stats.** Summary figures of the one series (`7-day avg`, `vs avg` on metric
+  detail), spoken as one `label value` node. A stat with no value is a dash and
+  is not spoken.
+- **Spoken once, by one owner at a time.** While a finger is on the chart the
+  `Scrubber` speaks the whole selected reading (`describe` carries every value
+  the panel shows, a missing one as "No record") and the panel's caption and
+  cells are excluded. At rest nothing is selected, so the panel speaks the
+  `LATEST · <day>, label value, …` reading itself, as one node, and the slider
+  says only "Nothing selected". `Scrubber.describe` and the panel must read the
+  same thing at every position. A screen with two panels for one instant (the
+  sleep night) speaks each chart's reading once, so each value is heard once per
+  chart.
+- **Open the day.** `onOpen` makes the whole panel an `Open <day>` button of at
+  least 48 dp. Pass it only for a day with a value: an action is a promise, and
+  an empty day has no screen behind it.
+
+The caller owns the reading. Metric detail, readiness and the two sleep charts
+each build the cells from the series the painter draws; the sleep charts read
+the stage from the night's timestamped boundaries (not the resample the painter
+draws) and a signal from its nearest sample within 15 minutes, else a dash.
+
 ### Layout primitives
 
 ```dart
@@ -373,7 +420,8 @@ Five rules:
    curve, and it does not take taps. **A mark without a `footnote` is a line
    nobody can read**: the footnote is the mark's only screen-reader form and
    the only thing that can say what it is. Keep the wording flat — a version
-   change is provenance, not something that happened to the user.
+   change is provenance, not something that happened to the user. Multi-day
+   charts (metric detail) use `xMarks`.
 4. **More than one colour means a `legend`.** Use the painters' own, never
    retyped: `Hypnogram.legend(p, l)`, `IntervalLadder.legend` (instance).
    The swatch is the mark's *solved* colour, so the key and the plot can never
diff --git a/lib/ui2/grammar.dart b/lib/ui2/grammar.dart
index 46e6afce8..f4f96f4ca 100644
--- a/lib/ui2/grammar.dart
+++ b/lib/ui2/grammar.dart
@@ -35,6 +35,7 @@ import '../l10n/decimal_text.dart' show parseTypedNumber;
 import '../l10n/presentation_text.dart';
 import 'dart:math' as math;
 
+import 'package:flutter/gestures.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter/rendering.dart' show RenderAbstractViewport;
 import 'package:lucide_icons_flutter/lucide_icons.dart';
@@ -177,6 +178,8 @@ class Scrubber extends StatelessWidget {
     // either direction places the cursor rather than doing nothing.
     final up = ((v ?? -step) + step).clamp(0.0, 1.0);
     final down = ((v ?? 1 + step) - step).clamp(0.0, 1.0);
+    // A local function so the heavy-work guard can follow the callback.
+    void end() => onEnd?.call();
     return Semantics(
       label: label,
       slider: true,
@@ -201,18 +204,48 @@ class Scrubber extends StatelessWidget {
               behavior: HitTestBehavior.opaque,
               onLongPressStart: (e) => set(e.localPosition),
               onLongPressMoveUpdate: (e) => set(e.localPosition),
-              onLongPressEnd: (_) => onEnd?.call(),
-              onLongPressCancel: () => onEnd?.call(),
+              onLongPressEnd: (_) => end(),
+              onLongPressCancel: end,
               child: child,
             );
           }
-          return Listener(
-            // Opaque, like Pressable. A `Listener` defers to its child by
-            // default, so the strip was only touchable where the painter
-            // happened to claim a hit — which is a coincidence, not a target.
+          // Decide dominance before accepting the arena: a diagonal move can
+          // cross horizontal slop while still belonging to the page scroll.
+          // Raw recognizers don't inherit the device's touch slop the way
+          // GestureDetector does, so hand it over explicitly.
+          final gs = MediaQuery.maybeGestureSettingsOf(c);
+          return RawGestureDetector(
             behavior: HitTestBehavior.opaque,
-            onPointerDown: (e) => set(e.localPosition),
-            onPointerMove: (e) => set(e.localPosition),
+            gestures: {
+              TapGestureRecognizer: GestureRecognizerFactoryWithHandlers<TapGestureRecognizer>(
+                () => TapGestureRecognizer(),
+                (r) => r
+                  ..gestureSettings = gs
+                  ..onTapUp = (e) => set(e.localPosition),
+              ),
+              _ScrubDragRecognizer: GestureRecognizerFactoryWithHandlers<_ScrubDragRecognizer>(
+                () => _ScrubDragRecognizer(),
+                (r) {
+                  r.gestureSettings = gs;
+                  r.dragStartBehavior = DragStartBehavior.down;
+                  r.onlyAcceptDragOnThreshold = true;
+                  r.onStart = (e) => set(e.localPosition);
+                  r.onUpdate = (e) => set(e.localPosition);
+                  r.onEnd = (_) => end();
+                  r.onCancel = end;
+                },
+              ),
+              LongPressGestureRecognizer: GestureRecognizerFactoryWithHandlers<LongPressGestureRecognizer>(
+                () => LongPressGestureRecognizer(),
+                (r) {
+                  r.gestureSettings = gs;
+                  r.onLongPressStart = (e) => set(e.localPosition);
+                  r.onLongPressMoveUpdate = (e) => set(e.localPosition);
+                  r.onLongPressEnd = (_) => end();
+                  r.onLongPressCancel = end;
+                },
+              ),
+            },
             child: child,
           );
         },
@@ -221,6 +254,418 @@ class Scrubber extends StatelessWidget {
   }
 }
 
+/// Owns the pending pointer displacement; Flutter owns the drag after intent
+/// is accepted. A long press uses its separate recognizer and stays free-axis.
+class _ScrubDragRecognizer extends HorizontalDragGestureRecognizer {
+  Offset _pending = Offset.zero;
+
+  @override
+  void addAllowedPointer(PointerDownEvent event) {
+    _pending = Offset.zero;
+    super.addAllowedPointer(event);
+  }
+
+  @override
+  void handleEvent(PointerEvent event) {
+    if (event is PointerMoveEvent) _pending += event.delta;
+    if (event is PointerPanZoomUpdateEvent) _pending = event.pan;
+    super.handleEvent(event);
+  }
+
+  @override
+  bool hasSufficientGlobalDistanceToAccept(PointerDeviceKind kind, double? slop) =>
+      super.hasSufficientGlobalDistanceToAccept(kind, slop) &&
+      _pending.dx.abs() > 1.5 * _pending.dy.abs();
+}
+
+/// One cell of a [ChartPanel]: a label and what the series reads at the shown
+/// instant. A null [value] reads a dash — nothing was recorded there, and the
+/// panel never fills it from a neighbour.
+@immutable
+class ChartPanelCell {
+  final String label;
+
+  /// The series colour: the swatch beside the label.
+  final Color? color;
+  final String? value;
+
+  /// The value's own ink; the plain ink when null.
+  final Color? valueColor;
+
+  /// Keep the swatch's width when [color] is null, so a cell whose colour
+  /// depends on its value does not rewrap its label between values.
+  final bool reserveSwatch;
+  const ChartPanelCell(this.label,
+      {this.color, this.value, this.valueColor, this.reserveSwatch = false});
+}
+
+/// ── CHART PANEL ── what a chart reads at one instant, always on screen ────
+///
+/// An inset box under the chart that is there at rest (`LATEST · <day>`, the
+/// newest reading) and while a finger is on the chart (`SELECTED · <day>`), so
+/// the chart never changes height under the thumb and nothing is readable only
+/// while it is held. Every series is listed with its value at that instant; a
+/// series with nothing there reads a dash — never a neighbour's value, never an
+/// interpolation.
+///
+/// One semantic owner at a time. While a finger is on the chart the slider
+/// ([Scrubber.describe]) speaks the whole selected reading, so the caption and
+/// the cells are excluded. At rest the slider has nothing selected, so the
+/// panel speaks the LATEST reading itself: the caption and every cell as one
+/// `LATEST · <day>, label value, …` node. Either way each shown value is
+/// spoken once. What the slider does not say is spoken here always: each of
+/// [stats] as one `label value` node, and [onOpen] as an `Open <day>` button.
+class ChartPanel extends StatelessWidget {
+  /// The caption's time: a day or a clock time. Null reads a dash.
+  final String? time;
+
+  /// A finger is on the chart: SELECTED, with a border and caption in [color].
+  final bool scrubbed;
+
+  /// The series colour for the caption and the border while [scrubbed].
+  final Color color;
+
+  /// The series read at [time]. A single cell is drawn large.
+  final List<ChartPanelCell> cells;
+
+  /// Summary figures of that one series (a 7-day average), spoken `label value`.
+  final List<ChartPanelCell> stats;
+
+  /// Every [time] the panel can show. The caption reserves the height of the
+  /// tallest of them, so a scrub never reflows the panel.
+  final List<String> timeSpan;
+
+  /// Opens the shown day; null on a day with no value, and then the panel
+  /// offers nothing to press and draws no chevron. When it is set the panel
+  /// ends its value line in a chevron.
+  final VoidCallback? onOpen;
+  final String? openLabel;
+
+  /// An optional small line under the cells (which devices fed the shown day).
+  /// Never spoken on its own: at rest it ends the resting reading; while
+  /// scrubbed the slider owns it.
+  final String? note;
+
+  /// Keep the note's line height even when [note] is empty, so the panel does
+  /// not change size between days with and without one.
+  final bool reserveNote;
+
+  const ChartPanel({
+    super.key,
+    required this.time,
+    required this.scrubbed,
+    required this.color,
+    required this.cells,
+    this.stats = const [],
+    this.timeSpan = const [],
+    this.onOpen,
+    this.openLabel,
+    this.note,
+    this.reserveNote = false,
+  });
+
+  static const panelKey = ValueKey('chart-panel');
+  static const captionKey = ValueKey('chart-panel-caption');
+  static const valueKey = ValueKey('chart-panel-value');
+  static const noteKey = ValueKey('chart-panel-note');
+  static const absent = '—';
+
+  /// The tallest caption of a span, per (span, width, style, scale, direction,
+  /// strings): measured once, not on every pointer move.
+  static final _captionHeights = <Object, double>{};
+
+  static const _border = 1.5;
+
+  @override
+  Widget build(BuildContext c) {
+    final p = P.of(c);
+    final big = cells.length == 1;
+    // Container counts the border as padding; take it off so a scrub moves
+    // nothing inside the panel.
+    final inset = scrubbed ? _border : 0.0;
+    final panel = Container(
+      key: panelKey,
+      decoration: BoxDecoration(
+        color: p.card2,
+        borderRadius: R.rMd,
+        border: scrubbed ? Border.all(color: color, width: _border) : null,
+      ),
+      padding: EdgeInsets.symmetric(
+          horizontal: S.x3 - inset, vertical: S.x2 - inset),
+      child: Column(
+        mainAxisSize: MainAxisSize.min,
+        crossAxisAlignment: CrossAxisAlignment.stretch,
+        children: [
+          Semantics(
+            container: !scrubbed,
+            label: scrubbed ? null : _reading(c),
+            child: ExcludeSemantics(child: _caption(c, p)),
+          ),
+          const SizedBox(height: S.x1),
+          _withOpenMark(
+            c,
+            p,
+            big: big,
+            child: _equal(c, [
+              for (final x in cells)
+                ExcludeSemantics(child: _cell(c, p, x, big: big)),
+            ]),
+          ),
+          if (stats.isNotEmpty) ...[
+            const SizedBox(height: S.x2),
+            _equal(c, [
+              for (final x in stats)
+                KeyedSubtree(
+                  key: ValueKey('chart-panel-stat:${x.label}'),
+                  child: Semantics(
+                    container: true,
+                    label: '${x.label} ${x.value ?? _none(c)}',
+                    child: ExcludeSemantics(child: _cell(c, p, x)),
+                  ),
+                ),
+            ]),
+          ],
+          if (reserveNote || (note ?? '').isNotEmpty) ...[
+            const SizedBox(height: S.x1),
+            ExcludeSemantics(
+              child: Text(
+                (note ?? '').isEmpty ? ' ' : note!,
+                key: noteKey,
+                maxLines: 1,
+                overflow: TextOverflow.ellipsis,
+                style: F.over.copyWith(color: p.ink3),
+              ),
+            ),
+          ],
+        ],
+      ),
+    );
+    if (onOpen == null) return panel;
+    return Semantics(
+      container: true,
+      button: true,
+      label: openLabel,
+      onTap: onOpen,
+      child: GestureDetector(
+        behavior: HitTestBehavior.opaque,
+        onTap: onOpen,
+        child: ConstrainedBox(
+            constraints: const BoxConstraints(minHeight: S.tap), child: panel),
+      ),
+    );
+  }
+
+  /// What a screen reader says for a value that was not recorded.
+  static String _none(BuildContext c) =>
+      AppLocalizations.of(c)?.metricDetailNoRecordLabel ?? 'No record';
+
+  /// The resting reading as one sentence: the caption, then each cell.
+  String _reading(BuildContext c) {
+    final l = AppLocalizations.of(c);
+    final none = _none(c);
+    final reading = [
+      '${l?.chartPanelLatest ?? 'LATEST'} · ${time ?? absent}',
+      for (final x in cells) '${x.label} ${x.value ?? none}',
+    ].join(', ');
+    return (note ?? '').isEmpty ? reading : '$reading · $note';
+  }
+
+  Widget _caption(BuildContext c, P p) {
+    final l = AppLocalizations.of(c);
+    final latest = l?.chartPanelLatest ?? 'LATEST';
+    final selected = l?.chartPanelSelected ?? 'SELECTED';
+    final measure = F.over.copyWith(fontWeight: FontWeight.w700);
+    final style = measure.copyWith(color: scrubbed ? color : p.ink2);
+    final scaler = MediaQuery.textScalerOf(c);
+    final dir = Directionality.of(c);
+    final now = time ?? absent;
+    return LayoutBuilder(builder: (_, box) {
+      double tallest(Iterable<String> times) {
+        var h = 0.0;
+        for (final mode in [latest, selected]) {
+          for (final at in times) {
+            final tp = TextPainter(
+              text: TextSpan(text: '$mode · $at', style: measure),
+              textDirection: dir,
+              textScaler: scaler,
+            )..layout(maxWidth: box.maxWidth);
+            h = math.max(h, tp.height);
+            tp.dispose();
+          }
+        }
+        return h;
+      }
+
+      final key = (
+        measure, scaler, box.maxWidth, dir, '$latest|$selected',
+        Object.hashAll(timeSpan), timeSpan.length
+      );
+      var height = _captionHeights[key];
+      if (height == null) {
+        height = tallest(timeSpan);
+        if (_captionHeights.length > 64) _captionHeights.clear();
+        _captionHeights[key] = height;
+      }
+      // A caption the span does not hold is measured alone.
+      if (!timeSpan.contains(now)) height = math.max(height, tallest([now]));
+      return ConstrainedBox(
+        constraints: BoxConstraints(minHeight: height),
+        child: Text('${scrubbed ? selected : latest} · $now',
+            key: captionKey, style: style),
+      );
+    });
+  }
+
+  /// The cells with a chevron at the trailing edge, centred on the value line,
+  /// when the day opens. A panel that offers to open ([openLabel]) keeps the
+  /// chevron's width on a day that cannot, so scrubbing onto a gap day never
+  /// rewraps a label or changes the height. The chevron is only a picture:
+  /// the panel already speaks `Open <day>`.
+  Widget _withOpenMark(BuildContext c, P p,
+      {required bool big, required Widget child}) {
+    if (onOpen == null && openLabel == null) return child;
+    const size = 18.0;
+    final tp = TextPainter(
+      text: TextSpan(
+          text: absent,
+          style: (big ? F.n34 : F.cap).copyWith(
+              fontWeight: big ? FontWeight.w700 : FontWeight.w600,
+              fontFeatures: const [FontFeature.tabularFigures()])),
+      textDirection: Directionality.of(c),
+      textScaler: MediaQuery.textScalerOf(c),
+    )..layout();
+    final line = tp.height;
+    tp.dispose();
+    final rtl = Directionality.of(c) == TextDirection.rtl;
+    return Row(
+      crossAxisAlignment: CrossAxisAlignment.end,
+      children: [
+        Expanded(child: child),
+        const SizedBox(width: S.x2),
+        SizedBox(
+          width: size,
+          height: line,
+          child: onOpen == null
+              ? null
+              : OverflowBox(
+                  minHeight: size,
+                  maxHeight: size,
+                  child: ExcludeSemantics(
+                    child: Icon(
+                        rtl ? LucideIcons.chevronLeft : LucideIcons.chevronRight,
+                        size: size,
+                        color: p.ink3),
+                  ),
+                ),
+        ),
+      ],
+    );
+  }
+
+  /// Equal-width cells: one row when they fit, wrapped when they do not.
+  Widget _equal(BuildContext c, List<Widget> items) {
+    if (items.isEmpty) return const SizedBox.shrink();
+    final scale = math.max(1.0, MediaQuery.textScalerOf(c).scale(1));
+    const gap = S.x3;
+    final minW = 92.0 * scale;
+    return LayoutBuilder(builder: (_, box) {
+      final w = box.maxWidth;
+      final cols = w.isFinite
+          ? ((w + gap) / (minW + gap)).floor().clamp(1, items.length)
+          : items.length;
+      final cellW = w.isFinite ? ((w - gap * (cols - 1)) / cols) - .01 : minW;
+      return Column(
+        mainAxisSize: MainAxisSize.min,
+        crossAxisAlignment: CrossAxisAlignment.stretch,
+        children: [
+          for (var r = 0; r * cols < items.length; r++) ...[
+            if (r > 0) const SizedBox(height: S.x2),
+            IntrinsicHeight(
+              child: Row(
+                crossAxisAlignment: CrossAxisAlignment.stretch,
+                children: [
+                  for (var k = 0; k < cols; k++) ...[
+                    if (k > 0) const SizedBox(width: gap),
+                    SizedBox(
+                        width: cellW,
+                        child: r * cols + k < items.length
+                            ? items[r * cols + k]
+                            : null),
+                  ],
+                ],
+              ),
+            ),
+          ],
+        ],
+      );
+    });
+  }
+
+  Widget _cell(BuildContext c, P p, ChartPanelCell cell, {bool big = false}) {
+    final present = cell.value != null;
+    final style = (big ? F.n34 : F.cap).copyWith(
+        color: present ? (cell.valueColor ?? p.ink) : p.ink3,
+        fontWeight: big ? FontWeight.w700 : FontWeight.w600,
+        fontFeatures: const [FontFeature.tabularFigures()]);
+    // A dash is as tall as a number, so a gap does not shorten the panel.
+    final tp = TextPainter(
+      text: TextSpan(text: absent, style: style),
+      textDirection: Directionality.of(c),
+      textScaler: MediaQuery.textScalerOf(c),
+    )..layout();
+    final height = tp.height;
+    tp.dispose();
+    return Column(
+      crossAxisAlignment: CrossAxisAlignment.start,
+      mainAxisAlignment: MainAxisAlignment.spaceBetween,
+      children: [
+        Row(crossAxisAlignment: CrossAxisAlignment.start, children: [
+          if (cell.color != null || cell.reserveSwatch) ...[
+            Padding(
+              padding: const EdgeInsets.only(top: 2.5),
+              child: SizedBox(
+                width: 9,
+                height: 9,
+                child: cell.color == null
+                    ? null
+                    : DecoratedBox(
+                        decoration: BoxDecoration(
+                          shape: BoxShape.circle,
+                          color: cell.color,
+                          border: Border.all(color: p.line, width: .5),
+                        ),
+                      ),
+              ),
+            ),
+            const SizedBox(width: S.x1),
+          ],
+          // A label is a constant, so it wraps rather than clipping.
+          Expanded(
+            child: Text(cell.label,
+                style: F.over.copyWith(
+                    color: p.ink3, fontWeight: FontWeight.w600)),
+          ),
+        ]),
+        Padding(
+          padding: const EdgeInsets.only(top: 2),
+          child: ConstrainedBox(
+            constraints: BoxConstraints(minHeight: height),
+            child: Row(key: big ? valueKey : null, children: [
+              Flexible(
+                child: FittedBox(
+                  fit: BoxFit.scaleDown,
+                  alignment: AlignmentDirectional.centerStart,
+                  child: Text(cell.value ?? absent, maxLines: 1, style: style),
+                ),
+              ),
+            ]),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
 /// The base card surface. Elevation, not outline.
 class Surface extends StatelessWidget {
   final Widget child;
diff --git a/lib/ui2/profile/gallery.dart b/lib/ui2/profile/gallery.dart
index 5fd5a0966..0bf06fdd7 100644
--- a/lib/ui2/profile/gallery.dart
+++ b/lib/ui2/profile/gallery.dart
@@ -46,6 +46,7 @@ import '../../compute/findings.dart';
 import '../../models/metric.dart';
 import '../../models/activity_suggestion.dart';
 import '../screens/detected_activities.dart';
+import '../screens/slot_scrub.dart';
 import '../activity/catalogue.dart';
 import '../activity/live.dart';
 import '../activity/picker.dart' show ActivityPicker, ActivityRow;
@@ -902,6 +903,76 @@ Map<String, Widget> extraCases() => {
           ),
         );
       }),
+      // The panel under a chart: at rest (LATEST), then while a finger is on
+      // the chart (SELECTED), the second with a day that has no reading.
+      'chart_panel': Builder(builder: (c) {
+        final p = P.of(c);
+        return Surface(
+          child: Column(children: [
+            ChartPanel(
+              time: 'Today',
+              timeSpan: const ['Today', 'Wednesday, 28 September'],
+              scrubbed: false,
+              color: p.on(C.red),
+              cells: [
+                ChartPanelCell('Resting heart rate',
+                    color: p.on(C.red), value: '52 bpm'),
+              ],
+              stats: const [
+                ChartPanelCell('7-day avg', value: '54 bpm'),
+                ChartPanelCell('vs avg', value: '−2 bpm'),
+              ],
+              onOpen: () {},
+              openLabel: 'Open Today',
+            ),
+            const SizedBox(height: S.x3),
+            ChartPanel(
+              time: 'Wednesday, 28 September',
+              timeSpan: const ['Today', 'Wednesday, 28 September'],
+              scrubbed: true,
+              color: p.on(C.red),
+              cells: [
+                ChartPanelCell('Resting heart rate', color: p.on(C.red)),
+              ],
+              stats: const [
+                ChartPanelCell('7-day avg', value: '54 bpm'),
+                ChartPanelCell('vs avg'),
+              ],
+            ),
+          ]),
+        );
+      }),
+      // A day-per-slot chart with its scroll-first scrubber and panel: bars,
+      // one empty day (a dash when touched), LATEST at rest.
+      'slot_scrub': Builder(builder: (c) {
+        final p = P.of(c);
+        final series = <double?>[30, 55, null, 70, 40, 65, 80];
+        return Surface(
+          child: SlotScrub(
+            series: series,
+            anchor: DateTime.now(),
+            bars: true,
+            label: 'Heart effort by day',
+            color: p.on(C.purple),
+            format: (v) => '${v.round()} points',
+            builder: (c, pick, scrub, panel) => Column(
+              crossAxisAlignment: CrossAxisAlignment.stretch,
+              children: [
+                SizedBox(
+                  height: 88,
+                  child: scrub(CustomPaint(
+                    size: Size.infinite,
+                    painter: Bars(series, p.on(C.purple),
+                        highlight: pick ?? -1),
+                  )),
+                ),
+                const SizedBox(height: S.x3),
+                panel,
+              ],
+            ),
+          ),
+        );
+      }),
       'chart_ring': Builder(builder: (c) {
         final p = P.of(c);
         return Surface(
diff --git a/lib/ui2/screens/health_screen.dart b/lib/ui2/screens/health_screen.dart
index 905680932..7526cc22a 100644
--- a/lib/ui2/screens/health_screen.dart
+++ b/lib/ui2/screens/health_screen.dart
@@ -29,6 +29,7 @@ import '../ui2.dart';
 import 'advanced.dart';
 import 'ecg.dart' show EcgEntryCard, pairedIsMaverickOf;
 import 'findings_log.dart';
+import 'slot_scrub.dart';
 import 'home_screen.dart';
 import 'investigate.dart';
 import 'metric_detail.dart';
@@ -1266,9 +1267,14 @@ class _HealthScreenState extends State<HealthScreen> with RevisionReload {
               'ms',
               l?.healthTimeFrequencyNonLinear ?? 'Time, frequency and non-linear',
               C.green,
-              preview: _hrvPreview(c, d),
               onTap: () => go(c, const Investigate('hrv'))),
         ),
+      // The chart is its own card, outside the deep dive's tap target: a touch
+      // on it reads a night, and only the card above opens Investigate.
+      if (rmssd != null) ...[
+        const SizedBox(height: S.x3),
+        Surface(child: _hrvPreview(c, d)),
+      ],
 
       // The research charts, all behind one door.
       const SizedBox(height: S.x3),
@@ -1282,7 +1288,7 @@ class _HealthScreenState extends State<HealthScreen> with RevisionReload {
     ]);
   }
 
-  /// The HRV preview inside the deep-dive card. Framed like every other chart:
+  /// The HRV preview. Framed like every other chart:
   /// what it is, what it is measured in, what the heights mean, and how far
   /// back it reaches — all read off the series actually drawn.
   Widget _hrvPreview(BuildContext c, HealthData d) {
@@ -1292,31 +1298,54 @@ class _HealthScreenState extends State<HealthScreen> with RevisionReload {
     // used to be the newest thirty STORED nights, which after a sync gap could
     // span two months while both axis labels — counted off the array — claimed
     // it spanned thirty. Nights with no record are holes, not joined across.
+    final end = DateTime.now();
     final win = denseDays(pts, days);
     final have = [for (final v in win) ?v];
     final axis = AxisSpec.of(have, ticks: 2);
     final p = P.of(c);
     final l = AppLocalizations.of(c);
-    return ChartFrame(
-      title: l?.healthRmssdOfLastNights(have.length, days) ??
-          'HRV, ${have.length} of the last $days nights',
-      unit: 'ms',
-      height: 48,
-      yAxis: axis,
-      xLabels: have.length < 2
-          ? const []
-          : [
-              l?.healthNightsAgo(days - 1) ?? '${days - 1} nights ago',
-              l?.healthSubLastNight ?? 'Last night',
-            ],
-      empty: have.length < 2
-          ? NoData(
-              message: l?.healthOneNightNotTrend ?? 'One night is not a trend yet')
-          : null,
+    final heading = l?.healthHeartRateVariability ?? 'Heart rate variability';
+    return SlotScrub(
       series: win,
-      child: CustomPaint(
-        size: Size.infinite,
-        painter: LineChart(win, p.on(C.green), t: animate(c, 1), axis: axis),
+      anchor: end,
+      bars: false,
+      label: heading,
+      color: p.on(C.green),
+      format: (v) => '${v.round()} ms',
+      // The axis calls the last slot "Last night"; so do the panel and slider.
+      dayWord: (i) =>
+          i == win.length - 1 ? (l?.healthSubLastNight ?? 'Last night') : null,
+      builder: (c, pick, scrub, panel) => Column(
+        crossAxisAlignment: CrossAxisAlignment.stretch,
+        children: [
+          ChartFrame(
+            title: l?.healthRmssdOfLastNights(have.length, days) ??
+                'HRV, ${have.length} of the last $days nights',
+            unit: 'ms',
+            height: 48,
+            yAxis: axis,
+            xLabels: have.length < 2
+                ? const []
+                : [
+                    l?.healthNightsAgo(days - 1) ?? '${days - 1} nights ago',
+                    l?.healthSubLastNight ?? 'Last night',
+                  ],
+            empty: have.length < 2
+                ? NoData(
+                    message: l?.healthOneNightNotTrend ??
+                        'One night is not a trend yet')
+                : null,
+            series: win,
+            child: scrub(CustomPaint(
+              size: Size.infinite,
+              painter: LineChart(win, p.on(C.green),
+                  t: animate(c, 1),
+                  axis: axis,
+                  selectedX: pick == null ? null : pick / (win.length - 1)),
+            )),
+          ),
+          if (have.length >= 2) ...[const SizedBox(height: S.x3), panel],
+        ],
       ),
     );
   }
diff --git a/lib/ui2/screens/metric_detail.dart b/lib/ui2/screens/metric_detail.dart
index f1dc38ecd..e7ad03706 100644
--- a/lib/ui2/screens/metric_detail.dart
+++ b/lib/ui2/screens/metric_detail.dart
@@ -10,6 +10,8 @@
 // the old UI ended up with forty different opinions about what a chart is.
 
 import '../../l10n/display_text.dart';
+import 'dart:math' as math;
+
 import 'package:collection/collection.dart';
 import 'package:flutter/material.dart';
 import 'package:lucide_icons_flutter/lucide_icons.dart';
@@ -716,6 +718,7 @@ Widget metricDayScreen(String key, String day) => switch (key) {
 class MetricDetail extends StatefulWidget {
   final String metricKey;
   final MetricData? data;
+
   const MetricDetail(this.metricKey, {super.key, this.data});
 
   @override
@@ -1498,7 +1501,7 @@ class _MetricDetailState extends State<MetricDetail> {
               style: F.over.copyWith(color: p.ink3),
             ),
           ),
-        if (_pick != null) _picked(c, spec, series, d),
+        if (win > 1) _panel(c, spec, series, d),
         // L4 — the coverage denominator, under the curve it belongs to.
         //
         // Deliberately unflattering, and gated to the ranges where it changes
@@ -1615,12 +1618,13 @@ class _MetricDetailState extends State<MetricDetail> {
     return l?.metricDetailSlotNoRecord(pretty) ?? '$pretty, no record';
   }
 
-  /// The touched day, and the door into it.
+  /// The panel under the chart: the newest reading at rest, the touched day
+  /// while a finger is on the chart, and the door into that day.
   ///
   /// A day with a value is a day that derived, so the door always leads
-  /// somewhere. A day with no value says so and offers nothing — an action
+  /// somewhere. A day with no value reads a dash and offers nothing — an action
   /// button is a promise, and there is no screen behind an empty day.
-  Widget _picked(
+  Widget _panel(
     BuildContext c,
     MetricSpec spec,
     List<double?> series,
@@ -1628,60 +1632,61 @@ class _MetricDetailState extends State<MetricDetail> {
   ) {
     final p = P.of(c);
     final l = AppLocalizations.of(c);
-    final i = _pick!.clamp(0, series.length - 1);
-    final day = _dayOfSlot(i, series.length);
+    final len = series.length;
+    var latest = len - 1;
+    while (latest > 0 && series[latest] == null) {
+      latest--;
+    }
+    final i = (_pick ?? latest).clamp(0, len - 1);
+    final day = _dayOfSlot(i, len);
     final v = series[i];
-    final attributed = _labelSources(d) && _labelsFor(day, d.coverage, d.sources).isNotEmpty;
-    final who = attributed ? _contributors(_labelsFor(day, d.coverage, d.sources)) : '';
+    final ub = unitBeside(spec.unit);
+    final u = ub.isEmpty ? '' : ' ${uiText(c, ub)}';
+    // The last 7 days up to today, whatever day is shown: the figure the shown
+    // day is set against. Only recorded days count; none recorded is a dash.
+    final week = [for (var k = math.max(0, len - 7); k < len; k++) ?series[k]];
+    final avg =
+        week.isEmpty ? null : week.reduce((a, b) => a + b) / week.length;
+    String? versus;
+    if (v != null && avg != null) {
+      final diff = v - avg;
+      final shown = _fmt(spec, diff.abs());
+      // No signed zero: a difference that rounds to nothing carries no sign.
+      final zero = shown == _fmt(spec, 0);
+      versus = '${zero ? shown : signed(diff, shown)}$u';
+    }
+    // The same gate and rule as `_slotSays`: a day with no attribution names
+    // none, and a single-device window reserves nothing.
+    final multi = _labelSources(d);
+    final who = multi ? _contributors(_labelsFor(day, d.coverage, d.sources)) : '';
     return Padding(
       padding: const EdgeInsets.only(top: S.x3),
-      child: Surface(
-        color: p.card2,
-        elevation: 0,
-        onTap: v == null ? null : () => go(c, _dayScreen(widget.metricKey, day)),
-        semanticLabel: [
-          v == null
-              ? (l?.metricDetailSlotNoRecord(prettyDay(day, l)) ??
-                  '${prettyDay(day, l)}, no record')
-              : (l?.metricDetailOpenDay(prettyDay(day, l)) ??
-                  'Open ${prettyDay(day, l)}'),
-          if (attributed) who,
-        ].join(' · '),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            Row(
-              children: [
-                Expanded(
-                  child: Text(
-                    dayNavLabel(day, l),
-                  style: F.body
-                      .copyWith(color: p.ink, fontWeight: FontWeight.w600),
-                  maxLines: 1,
-                  overflow: TextOverflow.ellipsis),
-            ),
-            const SizedBox(width: S.x3),
-            Text(
-              v == null
-                  ? (l?.metricDetailNoRecordLabel ?? 'No record')
-                  : '${_fmt(spec, v)} ${unitBeside(spec.unit)}'.trimRight(),
-              style: v == null
-                  ? F.cap.copyWith(color: p.ink3)
-                  : F.n17.copyWith(color: p.ink),
-            ),
-            if (v != null) ...[
-              const SizedBox(width: S.x2),
-              Icon(LucideIcons.chevronRight, size: 18, color: p.ink3),
-            ],
-          ]),
-          // WHICH DEVICE, second line, only under the gate. A day-level scalar
-          // from a merged substrate has no single producer, so this names the
-          // SET (final-plan §4.4) and never picks one of two.
-          if (attributed) ...[
-            const SizedBox(height: S.x1),
-            Text(who, style: F.over.copyWith(color: p.ink3)),
-          ],
-        ]),
+      child: ChartPanel(
+        // Scrubbed onto a no-value day the slider names no device, so the
+        // panel does not either: the screen shows what the slider says.
+        note: _pick != null && v == null ? '' : who,
+        reserveNote: multi,
+        time: dayNavLabel(day, l),
+        timeSpan: [
+          for (var k = 0; k < len; k++) dayNavLabel(_dayOfSlot(k, len), l),
+        ],
+        scrubbed: _pick != null,
+        color: p.on(spec.color),
+        cells: [
+          ChartPanelCell(uiText(c, spec.title),
+              color: p.on(spec.color),
+              value: v == null ? null : '${_fmt(spec, v)}$u'),
+        ],
+        stats: [
+          ChartPanelCell(l?.chartPanelSevenDayAvg ?? '7-day avg',
+              value: avg == null ? null : '${_fmt(spec, avg)}$u'),
+          ChartPanelCell(l?.chartPanelVsAvg ?? 'vs avg', value: versus),
+        ],
+        onOpen: v == null
+            ? null
+            : () => go(c, _dayScreen(widget.metricKey, day)),
+        openLabel: l?.metricDetailOpenDay(prettyDay(day, l)) ??
+            'Open ${prettyDay(day, l)}',
       ),
     );
   }
diff --git a/lib/ui2/screens/month_grid.dart b/lib/ui2/screens/month_grid.dart
index 760b6763e..8b0e8e229 100644
--- a/lib/ui2/screens/month_grid.dart
+++ b/lib/ui2/screens/month_grid.dart
@@ -30,6 +30,7 @@ import '../../l10n/app_localizations.dart';
 import '../ui2.dart';
 import 'home_screen.dart' show ChartPoint, denseDays, pointsOf;
 import 'metric_detail.dart' show MetricSpec, specOf;
+import 'slot_scrub.dart';
 
 /// Days on screen. One month, and the same window every trend card uses.
 const int kGridDays = 30;
@@ -53,11 +54,15 @@ class GridRow {
     required this.have,
     required this.historyDays,
     required this.ranged,
+    required this.anchor,
   });
 
   final MetricSpec spec;
   final String key;
 
+  /// The calendar day of the last cell: the day the row was built.
+  final DateTime anchor;
+
   /// Per day, oldest first: where the day sat against the usual range, or null
   /// for a day with no value or a row with no range.
   final List<Side?> cells;
@@ -88,6 +93,7 @@ List<Side?> sideCells(List<double?> window, UsualRange? band) => [
 
 /// Build one domain's row from its stored points.
 GridRow gridRow(String key, List<ChartPoint> points) {
+  final anchor = DateTime.now();
   final window = denseDays(points, kGridDays);
   final history = [for (final p in points) p.v];
   final band = usualRangeFor(key, history, null);
@@ -98,6 +104,7 @@ GridRow gridRow(String key, List<ChartPoint> points) {
     have: window.where((v) => v != null).length,
     historyDays: history.length,
     ranged: band != null,
+    anchor: anchor,
   );
 }
 
@@ -250,16 +257,35 @@ class MonthGrid extends StatelessWidget {
                             'value. ${r.cells.where((s) => s == Side.below).length} '
                             'below and ${r.cells.where((s) => s == Side.above).length} '
                             'above your usual range.',
-                    child: SizedBox(
-                      height: 22,
-                      child: CustomPaint(
-                        size: Size.infinite,
-                        painter: _SideStrip(
-                          r.cells,
-                          (s) => _cellInk(p, r, s),
-                          p.line,
-                          p.ink,
-                        ),
+                    // A cell is a day: the finger reads where that day sat
+                    // against the usual range, in the panel under the strip.
+                    // The 22 pt belongs to the strip alone.
+                    child: SlotScrub(
+                      key: ValueKey('grid-scrub:${r.key}'),
+                      series: [for (final s in r.cells) s?.index.toDouble()],
+                      anchor: r.anchor,
+                      bars: true,
+                      label: uiText(c, r.spec.title),
+                      color: p.on(r.spec.color),
+                      format: (v) => usualWord(l, Side.values[v.round()]),
+                      builder: (c, pick, scrub, panel) => Column(
+                        crossAxisAlignment: CrossAxisAlignment.stretch,
+                        children: [
+                          SizedBox(
+                            height: 22,
+                            child: scrub(CustomPaint(
+                              size: Size.infinite,
+                              painter: _SideStrip(
+                                r.cells,
+                                (s) => _cellInk(p, r, s),
+                                p.line,
+                                p.ink,
+                              ),
+                            )),
+                          ),
+                          const SizedBox(height: S.x2),
+                          panel,
+                        ],
                       ),
                     ),
                   ),
diff --git a/lib/ui2/screens/readiness_detail.dart b/lib/ui2/screens/readiness_detail.dart
index 3e17a1a8f..2c1140962 100644
--- a/lib/ui2/screens/readiness_detail.dart
+++ b/lib/ui2/screens/readiness_detail.dart
@@ -53,6 +53,11 @@ class ReadinessData {
   /// as five consecutive days.
   final List<double?> series;
 
+  /// The calendar day [series] ends on: the day it was densified, not the day
+  /// it is drawn. A screen left open across midnight keeps dating its scores
+  /// with the days they are from. Null (a fixture) reads the day it is drawn.
+  final DateTime? anchor;
+
   /// `todayHeadlineOf` off the same `getToday()`: the state and update note
   /// Home shows beside this number.
   final Map<String, dynamic> head;
@@ -76,6 +81,7 @@ class ReadinessData {
     this.inputsUsed = 0,
     this.heldOverNight,
     this.series = const [],
+    this.anchor,
     this.absentDiag,
     this.insightsStale,
   });
@@ -89,10 +95,12 @@ class ReadinessData {
     final overview = await repo.getDayOverview(date);
     final chart = await repo.getChart('recovery');
     final readiness = metricOf(overview['readiness']);
+    final anchor = DateTime.now();
     return ReadinessData(
       day: date,
       readiness: readiness,
       series: denseDays(pointsOf(chart), 90),
+      anchor: anchor,
       absentDiag: readiness.value != null
           ? null
           : await LocalDb.readinessAbsentDiag(date),
@@ -134,6 +142,7 @@ class ReadinessData {
       insightsStale: staleReasonOf(cd),
       heldOverNight: heldOverNightOf(today),
       series: denseDays(pointsOf(chart), 90),
+      anchor: DateTime.now(),
       // Only read when there is nothing to explain away — a scored day has no
       // diag in its bundle anyway, and this is one more day_result decode.
       //
@@ -406,7 +415,9 @@ class _ReadinessDetailState extends State<ReadinessDetail> {
     // "Steady" is the usual band; abstains under two weeks of scored days.
     final band = usualRangeFor('readiness', scored, null);
     final pick = _pick == null || _pick! >= win.length ? null : _pick;
-    final n = DateTime.now();
+    // The day the series was built for, never the day it is drawn.
+    final n = d.anchor ?? DateTime.now();
+    final behindToday = calendarDaysBetween(n, DateTime.now());
     String dayOf(int i) => prettyDay(
         dayLabelOf(DateTime(n.year, n.month, n.day - (win.length - 1 - i))), l);
     String says(int i) {
@@ -431,9 +442,12 @@ class _ReadinessDetailState extends State<ReadinessDetail> {
         // already counts it this way; the two screens dated one chart
         // differently.
         xLabels: [
-          l?.readinessDetailDaysAgo(win.length - 1) ??
-              '${win.length - 1} day${win.length == 2 ? '' : 's'} ago',
-          l?.readinessDetailToday ?? 'Today',
+          l?.readinessDetailDaysAgo(win.length - 1 + behindToday) ??
+              '${win.length - 1 + behindToday} day'
+                  '${win.length - 1 + behindToday == 1 ? '' : 's'} ago',
+          behindToday <= 0
+              ? (l?.readinessDetailToday ?? 'Today')
+              : dayOf(win.length - 1),
         ],
         series: win,
         legend: [
@@ -472,12 +486,39 @@ class _ReadinessDetailState extends State<ReadinessDetail> {
                 ),
               ),
       ),
-      if (pick != null) ...[
-        const SizedBox(height: S.x2),
-        ExcludeSemantics(
-          child: Text(says(pick),
-              style: F.cap.copyWith(color: p.ink, fontWeight: FontWeight.w600)),
-        ),
+      // Always there: the newest scored day at rest, the touched one while a
+      // finger is on the chart. The slider speaks the selection; the panel is
+      // the same reading in print.
+      if (win.length >= 2) ...[
+        const SizedBox(height: S.x3),
+        Builder(builder: (c) {
+          var latest = win.length - 1;
+          while (latest > 0 && win[latest] == null) {
+            latest--;
+          }
+          final i = pick ?? latest;
+          final v = win[i];
+          final band = v == null ? null : readinessBand(v, l);
+          String dayName(int k) {
+            final day =
+                dayLabelOf(DateTime(n.year, n.month, n.day - (win.length - 1 - k)));
+            return dayNavLabel(day, l);
+          }
+
+          return ChartPanel(
+            time: pick == null && v == null ? null : dayName(i),
+            timeSpan: [for (var k = 0; k < win.length; k++) dayName(k)],
+            scrubbed: pick != null,
+            color: p.on(C.green),
+            cells: [
+              ChartPanelCell(l?.readinessDetailTitle ?? 'Recovery',
+                  color: band == null ? null : p.on(band.color),
+                  reserveSwatch: true,
+                  value: v == null ? null : '${v.round()} · ${band!.label}',
+                  valueColor: band == null ? null : p.on(band.color)),
+            ],
+          );
+        }),
       ],
     ]);
   }
diff --git a/lib/ui2/screens/sleep_detail.dart b/lib/ui2/screens/sleep_detail.dart
index 30c2a1278..2eadcbb8f 100644
--- a/lib/ui2/screens/sleep_detail.dart
+++ b/lib/ui2/screens/sleep_detail.dart
@@ -289,6 +289,25 @@ class SleepData {
     ];
   }
 
+  /// The stage at second [t], read from the night's own timestamped
+  /// boundaries rather than from the 240-column resample [stagesOf] draws, so a
+  /// one-second step across a boundary changes the stage. `known` is false when
+  /// the night carries no staging at all; a stretch the band did not observe is
+  /// known, with a null stage.
+  static (bool, SleepStage?) stageAt(Map<String, Object?> night, int t) {
+    final pts = night['hypnogram'];
+    if (pts is! List) return (false, null);
+    final ts = <int>[], st = <SleepStage?>[];
+    for (final e in pts) {
+      if (e is Map && e['t'] is num) {
+        ts.add((e['t'] as num).round());
+        st.add(_stageOf(e['stage']));
+      }
+    }
+    if (ts.length < 2) return (false, null);
+    return (true, st[_indexAt(ts, t)]);
+  }
+
   static int _indexAt(List<int> ts, int t) {
     var lo = 0;
     for (var i = 0; i < ts.length; i++) {
@@ -512,7 +531,11 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
   /// previous night drawn under the new date.
   bool _failed = false;
   bool _saving = false; // an override write + its forced re-derive is in flight
-  double? _scrub; // 0..1 across the night
+  /// The instant both night charts have selected, in epoch seconds. One value
+  /// for both: a device's night and ours can have different bounds, so a
+  /// fraction of one is a different time on the other. A chart whose night does
+  /// not contain the instant shows no cursor.
+  int? _scrubT;
 
   /// Whose staging the hypnogram shows: null for ours, else a device id from
   /// [SleepData.deviceNights].
@@ -664,7 +687,7 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
   void _goDay(String day) {
     setState(() {
       _day = sleepStepperDay(day, (_d ?? _lastGood)?.latestDay);
-      _scrub = null;
+      _scrubT = null;
       _overrideFailed = null;
       _loading = true;
       _failed = false;
@@ -844,17 +867,15 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
           selected: _staging,
           onSelect: (id) => setState(() {
             _staging = id;
-            _scrub = null;
+            _scrubT = null;
           }),
         ),
         const SizedBox(height: S.x2),
       ],
       if (_deviceNight(d) case final dn?)
         _night(c, p, d, dn, device: dn)
-      else ...[
+      else
         _night(c, p, d, n),
-        if (_scrub != null) _scrubCard(c, p, d),
-      ],
 
       // ── 2b · WHOSE WINDOW IS THIS ──
       ...?_windowCard(c, p, d, n),
@@ -1363,8 +1384,9 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
               clockOfTs(t0 + (t1 - t0) ~/ 2),
             clockOfTs(t1),
           ],
-          child: _labelledHypnogram(c, p, stages, n, lane, totals),
+          child: _labelledHypnogram(c, p, d, stages, n, lane, totals),
         ),
+        _scrubPanel(c, p, d, n),
         if (device != null) ..._deviceStaging(c, p, device),
         // Not our staging: say whose it is, wherever it is drawn.
         if (device == null && n['sleep_source'] == 'vendor_staged') ...[
@@ -1496,27 +1518,37 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
   /// and the 44 pt tap rule does not apply to a continuous readout. What DOES
   /// apply is that the readout has to exist without a pointer — [Scrubber]
   /// carries the slider role and speaks [describe] at each step.
-  Widget _hypnogram(BuildContext c, P p, List<SleepStage?> stages,
+  Widget _hypnogram(BuildContext c, P p, SleepData d, List<SleepStage?> stages,
           Map<String, dynamic> n, double height) =>
       Scrubber(
-        value: _scrub,
-        onChanged: (v) => setState(() => _scrub = v),
+        value: _fracIn(_scrubT, _spanOf(n)),
+        onChanged: (v) => setState(() => _scrubT = _instantAt(v, _spanOf(n))),
         label: AppLocalizations.of(c)?.sleepDetailHypnogramLabel ?? 'Hypnogram',
         describe: (v) {
           final l = AppLocalizations.of(c);
           final t0 = (n['onset_ts'] as num?)?.toInt();
           final t1 = (n['wake_ts'] as num?)?.toInt();
-          final st = stages.isEmpty
-              ? null
-              : stages[(v * (stages.length - 1)).round().clamp(0, stages.length - 1)];
           final at = (t0 == null || t1 == null || t1 <= t0)
               ? (l?.sleepDetailPercentThroughNight((v * 100).round()) ??
                   '${(v * 100).round()}% through the night')
               : clockOfTs(t0 + ((t1 - t0) * v).round());
-          final stageName = st == null
-              ? (l?.sleepDetailNotMeasured ?? 'not measured')
-              : _stageName(c, st);
-          return l?.sleepDetailScrubAt(at, stageName) ?? '$at, $stageName';
+          // The same boundaries the panel reads, at the same second.
+          final (known, st) = (t0 == null || t1 == null || t1 <= t0)
+              ? (
+                  stages.isNotEmpty,
+                  stages.isEmpty
+                      ? null
+                      : stages[(v * (stages.length - 1))
+                          .round()
+                          .clamp(0, stages.length - 1)]
+                )
+              : SleepData.stageAt(n, t0 + ((t1 - t0) * v).round());
+          final base = _scrubBase(c, at, known, st);
+          // The panel under this chart is silent while a finger is on it, so
+          // the slider speaks the whole reading, signals included.
+          return (t0 == null || t1 == null || t1 <= t0)
+              ? base
+              : _scrubSays(c, p, d, base, t0 + ((t1 - t0) * v).round());
         },
         child: SizedBox(
           height: height,
@@ -1536,11 +1568,11 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
                           painter: Hypnogram(st, p, t: animate(c, 1))),
                 ),
             ]),
-            if (_scrub != null)
+            if (_fracIn(_scrubT, _spanOf(n)) case final f?)
               // Aligned by fraction rather than by a measured offset, so the
               // cursor needs no width from the layout.
               Align(
-                alignment: Alignment(_scrub! * 2 - 1, 0),
+                alignment: Alignment(f * 2 - 1, 0),
                 child: SizedBox(width: 2, height: double.infinity,
                     child: ColoredBox(color: p.ink)),
               ),
@@ -1548,16 +1580,41 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
         ),
       );
 
-  /// What every signal read at the scrubbed instant. Each line abstains on its
-  /// own — a night with no respiration series still shows heart rate.
-  Widget _scrubCard(BuildContext c, P p, SleepData d) {
-    final l = AppLocalizations.of(c);
-    final n = d.night;
+  /// The stretch a night's chart runs over: onset to wake, or a unit-less
+  /// stand-in when the night has no bounds (then the cursor is a percentage and
+  /// only the hypnogram, which needs no clock, uses it).
+  static (int, int) _spanOf(Map<String, dynamic> n) {
     final t0 = (n['onset_ts'] as num?)?.toInt();
     final t1 = (n['wake_ts'] as num?)?.toInt();
-    if (t0 == null || t1 == null || t1 <= t0) return const SizedBox.shrink();
-    final t = t0 + ((t1 - t0) * _scrub!).round();
+    return (t0 == null || t1 == null || t1 <= t0) ? (0, 1000000) : (t0, t1);
+  }
+
+  /// Where [t] sits across [span], or null when it is outside it.
+  static double? _fracIn(int? t, (int, int) span) =>
+      t == null || t < span.$1 || t > span.$2
+          ? null
+          : (t - span.$1) / (span.$2 - span.$1);
 
+  static int _instantAt(double v, (int, int) span) =>
+      span.$1 + ((span.$2 - span.$1) * v).round();
+
+  /// The slider's first words: the time and, when the night is staged at all,
+  /// the stage there ("not measured" for a known hole). A night with no
+  /// staging says no stage, as its panel shows none.
+  String _scrubBase(BuildContext c, String at, bool known, SleepStage? stage) {
+    if (!known) return at;
+    final l = AppLocalizations.of(c);
+    final name = stage == null
+        ? (l?.sleepDetailNotMeasured ?? 'not measured')
+        : _stageName(c, stage);
+    return l?.sleepDetailScrubAt(at, name) ?? '$at, $name';
+  }
+
+  /// The night's signals at second [t]: the cells the panel lists under the
+  /// stage, and what the slider speaks, from one place.
+  List<ChartPanelCell> _signalCells(
+      BuildContext c, P p, SleepData d, int t) {
+    final l = AppLocalizations.of(c);
     num? at(String key) {
       final list = d.timeline[key];
       if (list is! List) return null;
@@ -1575,52 +1632,100 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
       return bestGap > 900 ? null : best;
     }
 
-    final stages = d.stages;
-    final stage = stages.isEmpty
-        ? null
-        : stages[(_scrub! * (stages.length - 1)).round()];
-    final items = <(String, String, Color)>[
-      if (at('hr') != null)
-        (l?.sleepDetailHeartRate ?? 'Heart rate',
-            sleepReadingText(l, at('hr')!.round(), 0, 'bpm'), C.red),
-      if (at('hrv') != null)
-        (l?.sleepDetailHrv ?? 'HRV',
-            sleepReadingText(l, at('hrv')!.round(), 0, 'ms'), C.green),
-      if (at('resp') != null)
-        (l?.sleepDetailBreathing ?? 'Breathing',
-            sleepReadingText(l, at('resp')!, 1, 'br/min'), C.teal),
-      if (at('skin_temp') != null)
-        (l?.sleepDetailTempRelative ?? 'Temp (rel.)',
-            sleepScrubTempDelta(at('skin_temp')!), C.orange),
+    // A signal gets a cell when the night recorded it at all; then a moment
+    // without it reads a dash rather than the cell disappearing.
+    bool recorded(String key) {
+      final list = d.timeline[key];
+      return list is List &&
+          list.any((e) => e is Map && e['t'] is num && e['v'] is num);
+    }
+
+    String? reading(String key, int places, String unit) {
+      final v = at(key);
+      return v == null
+          ? null
+          : sleepReadingText(l, places == 0 ? v.round() : v, places, unit);
+    }
+
+    return [
+      if (recorded('hr'))
+        ChartPanelCell(l?.sleepDetailHeartRate ?? 'Heart rate',
+            color: p.on(C.red), value: reading('hr', 0, 'bpm')),
+      if (recorded('hrv'))
+        ChartPanelCell(l?.sleepDetailHrv ?? 'HRV',
+            color: p.on(C.green), value: reading('hrv', 0, 'ms')),
+      if (recorded('resp'))
+        ChartPanelCell(l?.sleepDetailBreathing ?? 'Breathing',
+            color: p.on(C.teal), value: reading('resp', 1, 'br/min')),
+      if (recorded('skin_temp'))
+        ChartPanelCell(l?.sleepDetailTempRelative ?? 'Temp (rel.)',
+            color: p.on(C.orange),
+            value: at('skin_temp') == null
+                ? null
+                : sleepScrubTempDelta(at('skin_temp')!)),
     ];
+  }
 
+  /// [base] (the time and stage) with every signal at second [t] after it:
+  /// the whole reading the panel shows, for the slider to speak while the
+  /// panel is silent.
+  String _scrubSays(BuildContext c, P p, SleepData d, String base, int t) {
+    final l = AppLocalizations.of(c);
+    final none = l?.metricDetailNoRecordLabel ?? 'No record';
+    return [
+      base,
+      for (final x in _signalCells(c, p, d, t))
+        '${x.label} ${x.value ?? none}',
+    ].join(', ');
+  }
+
+  /// The panel under a night chart: at rest the stage and every signal at wake
+  /// (LATEST), while scrubbing the same at that instant (SELECTED). Both
+  /// charts share one scrub fraction; each panel reads its own chart's instant.
+  ///
+  /// The stage comes from the night's timestamped boundaries ([n], so a
+  /// device's own staging reads its own night); each signal is its nearest
+  /// reading within 15 minutes or a dash — never a neighbour further away.
+  Widget _scrubPanel(BuildContext c, P p, SleepData d, Map<String, dynamic> n) {
+    final l = AppLocalizations.of(c);
+    final t0 = (n['onset_ts'] as num?)?.toInt();
+    final t1 = (n['wake_ts'] as num?)?.toInt();
+    if (t0 == null || t1 == null || t1 <= t0) return const SizedBox.shrink();
+    // The shared instant, when this night contains it; else this chart rests.
+    final scrubbed = _fracIn(_scrubT, (t0, t1)) != null;
+    final t = scrubbed ? _scrubT! : t1;
+
+    final (known, stage) = SleepData.stageAt(n, t);
+    final pigment = stage == null ? null : Hypnogram.pigment[stage];
+    final stageInk = pigment == null ? null : p.on(pigment);
+    String sentence(String s) =>
+        s.isEmpty ? s : s[0].toUpperCase() + s.substring(1);
+    final cells = <ChartPanelCell>[
+      if (known)
+        ChartPanelCell(sentence(l?.sleepDetailUnitStage ?? 'stage'),
+            color: stageInk,
+            // A hole has no pigment; it keeps the swatch's width all the same.
+            reserveSwatch: true,
+            value: stage == null
+                ? (l?.sleepDetailNotMeasuredCap ?? 'Not measured')
+                : _stageName(c, stage),
+            valueColor: stageInk ?? p.ink2),
+      ..._signalCells(c, p, d, t),
+    ];
+    if (cells.isEmpty) return const SizedBox.shrink();
     return Padding(
       padding: const EdgeInsets.only(top: S.x3),
-      child: Surface(
-        color: p.card2,
-        elevation: 0,
-        child: Column(children: [
-          Row(children: [
-            Text(clockOfTs(t),
-                style: F.body.copyWith(color: p.ink, fontWeight: FontWeight.w600)),
-            const Spacer(),
-            if (stage != null)
-              Pill(_stageName(c, stage), Hypnogram.pigment[stage] ?? C.blue)
-            else if (stages.isNotEmpty)
-              // Not a stage, so not a Pill: this instant has no colour because
-              // the band was not recording it.
-              Text(l?.sleepDetailNotMeasuredCap ?? 'Not measured',
-                  style: F.cap.copyWith(color: p.ink3)),
-          ]),
-          if (items.isEmpty) ...[
-            const SizedBox(height: S.x3),
-            Text(l?.sleepDetailNoSignalAtMoment ?? 'No signal recorded at this moment.',
-                style: F.cap.copyWith(color: p.ink3)),
-          ] else ...[
-            const SizedBox(height: S.x4),
-            InlineMetrics(items),
-          ],
-        ]),
+      child: ChartPanel(
+        time: clockOfTs(t),
+        // Every half hour and the wake itself: the caption reserves the
+        // tallest of these, so a scrub never reflows the panel.
+        timeSpan: [
+          for (var s = t0; s < t1; s += 1800) clockOfTs(s),
+          clockOfTs(t1),
+        ],
+        scrubbed: scrubbed,
+        color: stageInk ?? p.ink2,
+        cells: cells,
       ),
     );
   }
@@ -1645,8 +1750,8 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
   /// Stages table under the chart carries the same figures.
   static const _nameShare = .3, _minPlotShare = .55;
 
-  Widget _labelledHypnogram(BuildContext c, P p, List<SleepStage?> stages,
-      Map<String, dynamic> n, double lane, Map<SleepStage, String> totals) {
+  Widget _labelledHypnogram(BuildContext c, P p, SleepData d,
+      List<SleepStage?> stages, Map<String, dynamic> n, double lane, Map<SleepStage, String> totals) {
     final l = AppLocalizations.of(c);
     final ink = Hypnogram.cols(p);
     final scaler = MediaQuery.textScalerOf(c);
@@ -1710,7 +1815,7 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
         // Spoken by the totals column, or by the scrubber's own readout.
         ExcludeSemantics(child: column(name, nameW, coloured: true)),
         const SizedBox(width: S.x2),
-        Expanded(child: _hypnogram(c, p, stages, n, lane * 4)),
+        Expanded(child: _hypnogram(c, p, d, stages, n, lane * 4)),
         if (withTotals) ...[
           const SizedBox(width: S.x2),
           Semantics(
@@ -2333,21 +2438,28 @@ class _SleepDetailState extends State<SleepDetail> with RevisionReload {
           // makes the two time bases one.
           child: linked
               ? Scrubber(
-                  value: _scrub,
-                  onChanged: (v) => setState(() => _scrub = v),
+                  value: _fracIn(_scrubT, (t0, t1)),
+                  onChanged: (v) =>
+                      setState(() => _scrubT = _instantAt(v, (t0, t1))),
                   label: loc?.sleepDetailThroughTheNight ?? 'Through the night',
-                  describe: (v) => clockOfTs(
-                      t0 + ((t1 - t0) * v).round()),
+                  describe: (v) {
+                    final t = _instantAt(v, (t0, t1));
+                    final (known, stage) = SleepData.stageAt(n, t);
+                    return _scrubSays(
+                        c, p, d, _scrubBase(c, clockOfTs(t), known, stage), t);
+                  },
                   child: CustomPaint(
                       size: Size.infinite,
                       painter: NightStack(series, colors,
-                          axes: axes, selectedX: _scrub, cursor: p.ink)),
+                          axes: axes,
+                          selectedX: _fracIn(_scrubT, (t0, t1)),
+                          cursor: p.ink)),
                 )
               : CustomPaint(
                   size: Size.infinite,
                   painter: NightStack(series, colors, axes: axes)),
         ),
-        if (linked && _scrub != null) _scrubCard(c, p, d),
+        if (linked) _scrubPanel(c, p, d, n),
       ]),
     );
   }
diff --git a/lib/ui2/screens/slot_scrub.dart b/lib/ui2/screens/slot_scrub.dart
new file mode 100644
index 000000000..5d958d8f8
--- /dev/null
+++ b/lib/ui2/screens/slot_scrub.dart
@@ -0,0 +1,125 @@
+// One day-per-slot chart that reads under the finger: a scroll-first
+// [Scrubber] over the plot and an always-present [ChartPanel] under it.
+//
+// Used by the Health HRV line, the two Workout bar charts and the month-grid
+// strips, which all share the same shape: `series` has one slot per calendar
+// day, the last slot is the caller's anchor day, a null slot is a day with nothing recorded. The
+// panel reads LATEST on the newest recorded day and SELECTED on the touched
+// one; a null day reads a dash, never a neighbour.
+import 'package:flutter/material.dart';
+
+import '../../data/day_label.dart';
+import '../../l10n/app_localizations.dart';
+import '../ui2.dart';
+import 'metric_detail.dart' show dayNavLabel;
+
+class SlotScrub extends StatefulWidget {
+  const SlotScrub({
+    super.key,
+    required this.series,
+    required this.anchor,
+    required this.bars,
+    required this.label,
+    required this.color,
+    required this.format,
+    required this.builder,
+    this.dayWord,
+  });
+
+  /// One slot per calendar day, oldest first, the last slot on [anchor].
+  final List<double?> series;
+
+  /// The calendar day of the last slot: the day the series was built for, not
+  /// the day it is touched. A chart left open across midnight keeps labelling
+  /// its data with the days the data is from.
+  final DateTime anchor;
+
+  /// Bars sit in the middle of their slot (`(i + .5) / n`); a line has its
+  /// points on the ends (`i / (n - 1)`).
+  final bool bars;
+
+  /// What the chart is, for the slider and the panel's cell.
+  final String label;
+
+  /// The series colour, already resolved for the theme.
+  final Color color;
+
+  /// A recorded value as the panel and the slider say it.
+  final String Function(double v) format;
+
+  /// The caller's own word for a slot (HRV calls its last slot "Last night"),
+  /// or null to use the day name. The panel and the slider both use it.
+  final String? Function(int slot)? dayWord;
+
+  /// [scrub] wraps the painted plot; [panel] goes under the chart; [pick] is
+  /// the touched slot (null at rest) for a painter that highlights it.
+  final Widget Function(BuildContext context, int? pick,
+      Widget Function(Widget plot) scrub, Widget panel) builder;
+
+  @override
+  State<SlotScrub> createState() => _SlotScrubState();
+}
+
+class _SlotScrubState extends State<SlotScrub> {
+  int? _pick;
+
+  int get _n => widget.series.length;
+
+  int _slot(double v) => widget.bars
+      ? (v * _n).floor().clamp(0, _n - 1)
+      : (v * (_n - 1)).round().clamp(0, _n - 1);
+
+  double _at(int i) => widget.bars ? (i + .5) / _n : i / (_n - 1);
+
+  String _day(BuildContext c, int slot) {
+    final word = widget.dayWord?.call(slot);
+    if (word != null) return word;
+    final a = widget.anchor;
+    return dayNavLabel(
+        dayLabelOf(DateTime(a.year, a.month, a.day - (_n - 1 - slot))),
+        AppLocalizations.of(c));
+  }
+
+  @override
+  Widget build(BuildContext c) {
+    final l = AppLocalizations.of(c);
+    final s = widget.series;
+    var latest = _n - 1;
+    while (latest > 0 && s[latest] == null) {
+      latest--;
+    }
+    // No slots at all: nothing to read, so an empty reading.
+    final shown = _n == 0 ? null : (_pick ?? latest).clamp(0, _n - 1);
+    final v = shown == null ? null : s[shown];
+    // No slot has a value: LATEST would name a day with no reading.
+    final none = _pick == null && v == null;
+    final panel = ChartPanel(
+      time: none || shown == null ? null : _day(c, shown),
+      timeSpan: [for (var i = 0; i < _n; i++) _day(c, i)],
+      scrubbed: _pick != null,
+      color: widget.color,
+      cells: [
+        ChartPanelCell(widget.label,
+            color: widget.color, value: v == null ? null : widget.format(v)),
+      ],
+    );
+    Widget scrub(Widget plot) => _n < 2
+        ? plot
+        : Scrubber(
+            value: _pick == null ? null : _at(_pick!),
+            step: 1 / (widget.bars ? _n : _n - 1),
+            label: widget.label,
+            describe: (x) {
+              final i = _slot(x);
+              final day = _day(c, i);
+              final at = s[i];
+              return at == null
+                  ? (l?.metricDetailSlotNoRecord(day) ?? '$day, no record')
+                  : '$day, ${widget.format(at)}';
+            },
+            onChanged: (x) => setState(() => _pick = _slot(x)),
+            child: plot,
+          );
+    return widget.builder(c, _pick, scrub, panel);
+  }
+}
diff --git a/lib/ui2/screens/start_card.dart b/lib/ui2/screens/start_card.dart
index 5b4771b1d..be101daf3 100644
--- a/lib/ui2/screens/start_card.dart
+++ b/lib/ui2/screens/start_card.dart
@@ -115,7 +115,11 @@ class StartCard extends StatelessWidget {
                       ]),
             boxShadow: p.el(3),
           ),
-          child: Row(
+          // IntrinsicHeight: in a scrolling page the height is unbounded and
+          // the Spacer below would assert; this gives the Column the height
+          // its own copy needs (never under the 190 floor above).
+          child: IntrinsicHeight(
+           child: Row(
             crossAxisAlignment: CrossAxisAlignment.end,
             children: [
               Expanded(
@@ -161,6 +165,7 @@ class StartCard extends StatelessWidget {
                 ),
               ),
             ],
+           ),
           ),
         ),
       ),
diff --git a/lib/ui2/screens/workout_screen.dart b/lib/ui2/screens/workout_screen.dart
index e89a12e1b..14e9ed5ac 100644
--- a/lib/ui2/screens/workout_screen.dart
+++ b/lib/ui2/screens/workout_screen.dart
@@ -40,6 +40,7 @@ import '../activity/picker.dart';
 import '../activity/poster.dart' show PosterStatRow;
 import '../activity/setup.dart';
 import '../activity/summary.dart';
+import 'slot_scrub.dart';
 import '../charts.dart';
 import '../profile/profile.dart' show ProfileAvatar, openProfile;
 import '../grammar.dart';
@@ -297,31 +298,48 @@ class _WorkoutScreenState extends State<WorkoutScreen> with RevisionReload {
     final loc = AppLocalizations.of(c);
     final end = d.trimpEnd ?? DateTime.now();
     final axis = AxisSpec.of([for (final v in d.tonnage7) ?v], floor: 0);
+    final title = loc?.workoutMechanicalLoadTitle ?? 'Mechanical load';
+    final unit = loc?.workoutKgLiftedUnit ?? 'kg lifted';
     return Surface(
-      child: ChartFrame(
-        title: loc?.workoutMechanicalLoadTitle ?? 'Mechanical load',
-        unit: loc?.workoutKgLiftedUnit ?? 'kg lifted',
-        height: 88,
-        yAxis: axis,
-        xLabels: [
-          for (var i = 6; i >= 0; i--)
-            _weekdayLetter(c, DateTime(end.year, end.month, end.day - i)),
-        ],
-        footnote: (loc?.workoutTonnageFootnoteIntro ??
-                'Reps × load over the sets you logged with a weight. ') +
-            (d.tonnagePartial
-                ? (loc?.workoutTonnageFootnotePartial ??
-                    'Sets logged without one are not in it, so '
-                        'this is a floor rather than a total. ')
-                : '') +
-            (loc?.workoutTonnageFootnoteOutro ??
-                'Exact for what you typed and worthless across exercises — '
-                    'kept out of strain and recovery for that reason.'),
+      child: SlotScrub(
         series: d.tonnage7,
-        child: CustomPaint(
-          size: Size.infinite,
-          painter: Bars(d.tonnage7, p.on(C.orange),
-              axis: axis, t: animate(context, 1)),
+        anchor: end,
+        bars: true,
+        label: title,
+        color: p.on(C.orange),
+        format: (v) => '${v.round()} $unit',
+        builder: (c, pick, scrub, panel) => Column(
+          crossAxisAlignment: CrossAxisAlignment.stretch,
+          children: [
+            ChartFrame(
+              title: title,
+              unit: unit,
+              height: 88,
+              yAxis: axis,
+              xLabels: [
+                for (var i = 6; i >= 0; i--)
+                  _weekdayLetter(c, DateTime(end.year, end.month, end.day - i)),
+              ],
+              footnote: (loc?.workoutTonnageFootnoteIntro ??
+                      'Reps × load over the sets you logged with a weight. ') +
+                  (d.tonnagePartial
+                      ? (loc?.workoutTonnageFootnotePartial ??
+                          'Sets logged without one are not in it, so '
+                              'this is a floor rather than a total. ')
+                      : '') +
+                  (loc?.workoutTonnageFootnoteOutro ??
+                      'Exact for what you typed and worthless across exercises — '
+                          'kept out of strain and recovery for that reason.'),
+              series: d.tonnage7,
+              child: scrub(CustomPaint(
+                size: Size.infinite,
+                painter: Bars(d.tonnage7, p.on(C.orange),
+                    highlight: pick ?? -1, axis: axis, t: animate(c, 1)),
+              )),
+            ),
+            const SizedBox(height: S.x3),
+            panel,
+          ],
         ),
       ),
     );
@@ -392,34 +410,55 @@ class _WorkoutScreenState extends State<WorkoutScreen> with RevisionReload {
             final end = d.trimpEnd ?? DateTime.now();
             final axis = AxisSpec.of([for (final v in d.trimp7) ?v], floor: 0);
             final days = d.trimp7.where((v) => v != null).length;
-            return ChartFrame(
-              title: loc?.workoutDailyLoadTitle ?? 'Heart effort by day',
-              unit: loc?.workoutTrimpUnit ?? 'points',
-              height: 88,
-              yAxis: axis,
-              // Seven slots, seven real dates. A day with nothing keeps its
-              // place and its letter, and draws as the gap it is.
-              xLabels: [
-                for (var i = 6; i >= 0; i--)
-                  _weekdayLetter(c, DateTime(end.year, end.month, end.day - i)),
-              ],
-              footnote: (loc?.workoutDailyLoadFootnoteIntro ??
-                      'Heart points with no cap: minutes in each heart-rate zone, harder zones counting more. Strain reads the same heart rate on a 0–21 scale. ') +
-                  (days == 7
-                      ? (loc?.workoutDailyLoadAllDays ?? 'Last seven days.')
-                      : (loc?.workoutDailyLoadPartialDays(days) ??
-                          '$days of the last '
-                              'seven days produced a figure.')),
+            final title = loc?.workoutDailyLoadTitle ?? 'Heart effort by day';
+            final unit = loc?.workoutTrimpUnit ?? 'points';
+            return SlotScrub(
               series: d.trimp7,
-              child: CustomPaint(
-                  size: Size.infinite,
-                  // Today is the last slot, always — not "the newest value".
-                  painter: Bars(d.trimp7, p.on(C.purple),
-                      highlight: d.trimp7.last == null ? -1 : 6,
-                      axis: axis,
-                      t: animate(context, 1)),
+              anchor: end,
+              bars: true,
+              label: title,
+              color: p.on(C.purple),
+              format: (v) => '${v.round()} $unit',
+              builder: (c, pick, scrub, panel) => Column(
+                crossAxisAlignment: CrossAxisAlignment.stretch,
+                children: [
+                  ChartFrame(
+                    title: title,
+                    unit: unit,
+                    height: 88,
+                    yAxis: axis,
+                    // Seven slots, seven real dates. A day with nothing keeps
+                    // its place and its letter, and draws as the gap it is.
+                    xLabels: [
+                      for (var i = 6; i >= 0; i--)
+                        _weekdayLetter(
+                            c, DateTime(end.year, end.month, end.day - i)),
+                    ],
+                    footnote: (loc?.workoutDailyLoadFootnoteIntro ??
+                            'Heart points with no cap: minutes in each heart-rate zone, harder zones counting more. Strain reads the same heart rate on a 0–21 scale. ') +
+                        (days == 7
+                            ? (loc?.workoutDailyLoadAllDays ??
+                                'Last seven days.')
+                            : (loc?.workoutDailyLoadPartialDays(days) ??
+                                '$days of the last '
+                                    'seven days produced a figure.')),
+                    series: d.trimp7,
+                    child: scrub(CustomPaint(
+                      size: Size.infinite,
+                      // Today is the last slot at rest — not "the newest
+                      // value"; a touch moves the highlight.
+                      painter: Bars(d.trimp7, p.on(C.purple),
+                          highlight:
+                              pick ?? (d.trimp7.last == null ? -1 : 6),
+                          axis: axis,
+                          t: animate(c, 1)),
+                    )),
                   ),
-                );
+                  const SizedBox(height: S.x3),
+                  panel,
+                ],
+              ),
+            );
               },
             ),
           ],
diff --git a/test/graphs_panel_devices_test.dart b/test/graphs_panel_devices_test.dart
new file mode 100644
index 000000000..87ef53a77
--- /dev/null
+++ b/test/graphs_panel_devices_test.dart
@@ -0,0 +1,155 @@
+// The per-day contributor line in the metric-detail ChartPanel (Sol r2 S8).
+// Upstream's pop-in named the devices behind the touched day ("Band + Ring");
+// the replacement panel must keep that line, reserve its height on a
+// multi-device window, and never speak it twice.
+import 'package:flutter/material.dart';
+import 'package:flutter/semantics.dart' show SemanticsNode;
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/l10n/app_localizations.dart';
+import 'package:openstrap_edge/ui2/profile/devices.dart' show DeviceOption;
+import 'package:openstrap_edge/ui2/screens/screens.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+const _noteKey = ValueKey('chart-panel-note');
+const _panelKey = ValueKey('chart-panel');
+const _bare = 3; // days ago with no attribution in the two-device window
+
+const _sources = <DeviceOption>[
+  (deviceId: '', label: 'Band', selectable: true, reason: null),
+  (deviceId: 'ring-A', label: 'Ring', selectable: true, reason: null),
+];
+
+String _day(int back) {
+  final n = DateTime.now();
+  final d = DateTime(n.year, n.month, n.day - back);
+  return '${d.year.toString().padLeft(4, '0')}-'
+      '${d.month.toString().padLeft(2, '0')}-${d.day.toString().padLeft(2, '0')}';
+}
+
+MetricData _data({required bool multi, int? gap}) {
+  final n = DateTime.now();
+  return MetricData(
+    daysAvailable: 10,
+    series: [
+      for (var back = 9; back >= 0; back--)
+        if (back != gap)
+        (
+          t: DateTime(n.year, n.month, n.day - back, 12)
+                  .millisecondsSinceEpoch ~/
+              1000,
+          v: 50.0 + back,
+        ),
+    ],
+    sources: multi ? _sources : const [],
+    coverage: multi
+        ? {
+            for (var b = 0; b < 10; b++)
+              if (b != _bare) _day(b): const ['', 'ring-A'],
+            // Today is fed by the ring alone: one name, not two.
+            _day(0): const ['ring-A'],
+          }
+        : const {},
+  );
+}
+
+Future<void> _open(WidgetTester t, {required bool multi, int? gap}) async {
+  t.view.physicalSize = const Size(390 * 3, 1800 * 3);
+  t.view.devicePixelRatio = 3;
+  addTearDown(t.view.reset);
+  await t.pumpWidget(MaterialApp(
+    locale: const Locale('en'),
+    localizationsDelegates: AppLocalizations.localizationsDelegates,
+    supportedLocales: AppLocalizations.supportedLocales,
+    theme: buildTheme(Brightness.light),
+    home: Scaffold(body: MetricDetail('resting_hr', data: _data(multi: multi, gap: gap))),
+  ));
+  await t.pumpAndSettle();
+  await t.tap(find.text('7 days'));
+  await t.pumpAndSettle();
+}
+
+Future<void> _scrubBack(WidgetTester t, int back) async {
+  final plot = find.descendant(
+      of: find.byType(ChartFrame).first, matching: find.byType(Scrubber));
+  final r = t.getRect(plot);
+  await t.tapAt(Offset(r.left + r.width * (6 - back) / 6, r.center.dy));
+  await t.pumpAndSettle();
+}
+
+String? _note(WidgetTester t) {
+  final f = find.byKey(_noteKey);
+  if (f.evaluate().isEmpty) return null;
+  return t.widget<Text>(f).data!.trim();
+}
+
+int _times(WidgetTester t, String what) {
+  var n = 0;
+  void walk(SemanticsNode x) {
+    final d = x.getSemanticsData();
+    for (final s in [d.label, d.value]) {
+      if (s.contains(what)) n++;
+    }
+    x.visitChildren((c) {
+      walk(c);
+      return true;
+    });
+  }
+
+  walk(t.binding.renderViews.first.owner!.semanticsOwner!.rootSemanticsNode!);
+  return n;
+}
+
+void main() {
+  testWidgets('two devices: the scrubbed day shows "Band + Ring"', (t) async {
+    await _open(t, multi: true);
+    await _scrubBack(t, 1);
+    expect(_note(t), 'Band + Ring');
+  });
+
+  testWidgets('at rest the latest day shows its contributors', (t) async {
+    await _open(t, multi: true);
+    expect(_note(t), 'Ring', reason: 'today is fed by one device only');
+  });
+
+  testWidgets('a day with no attribution shows no text and the panel does not '
+      'change size', (t) async {
+    await _open(t, multi: true);
+    await _scrubBack(t, 1);
+    final withNote = t.getRect(find.byKey(_panelKey));
+    await _scrubBack(t, _bare);
+    expect(_note(t), '');
+    expect(t.getRect(find.byKey(_panelKey)), withNote);
+  });
+
+  testWidgets('a day with coverage but no value shows no device line, as the '
+      'slider says', (t) async {
+    await _open(t, multi: true, gap: 2);
+    await _scrubBack(t, 2);
+    expect(_note(t), '', reason: 'the slider names no device for a no-value day');
+    expect(find.text('Band + Ring'), findsNothing);
+  });
+
+  testWidgets('single device: no line and no reserved space', (t) async {
+    await _open(t, multi: false);
+    expect(find.byKey(_noteKey), findsNothing);
+    final rest = t.getRect(find.byKey(_panelKey)).height;
+    await _scrubBack(t, 1);
+    expect(find.byKey(_noteKey), findsNothing);
+    expect(t.getRect(find.byKey(_panelKey)).height, rest);
+
+    await t.pumpWidget(const SizedBox());
+    await _open(t, multi: true);
+    expect(t.getRect(find.byKey(_panelKey)).height, greaterThan(rest),
+        reason: 'the multi-device window reserves the line');
+  });
+
+  testWidgets('the contributors are spoken exactly once', (t) async {
+    final h = t.ensureSemantics();
+    await _open(t, multi: true);
+    expect(_times(t, '· Ring'), 1,
+        reason: 'at rest: the resting reading (the device pill is not a note)');
+    await _scrubBack(t, 1);
+    expect(_times(t, 'Band + Ring'), 1, reason: 'scrubbed: the slider');
+    h.dispose();
+  });
+}
diff --git a/test/graphs_review_cr1_test.dart b/test/graphs_review_cr1_test.dart
new file mode 100644
index 000000000..206d4d45d
--- /dev/null
+++ b/test/graphs_review_cr1_test.dart
@@ -0,0 +1,321 @@
+// Review round 1 on the Graphs PR: one test per finding that held up.
+//   2  a missing statistic is spoken as "No record", not skipped
+//   3  a panel with no cells draws nothing and does not throw
+//   5  a screen dates its history from the day the series was built
+//   6  a missing day keeps the swatch width, so the label never rewraps
+//   7  a gap in a device's epochs is a gap, not the stage before it
+//   8  both sleep charts share one instant, not one fraction
+//   9  a night with no staging does not say "not measured"
+//  10  an empty series reads empty and does not throw
+import 'package:flutter/material.dart';
+import 'package:flutter/semantics.dart' show SemanticsNode;
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/compute/vendor_sleep.dart';
+import 'package:openstrap_edge/data/day_label.dart';
+import 'package:openstrap_edge/l10n/app_localizations.dart';
+import 'package:openstrap_edge/models/metric.dart';
+import 'package:openstrap_edge/state/clock_format.dart';
+import 'package:openstrap_edge/ui2/screens/screens.dart';
+import 'package:openstrap_edge/ui2/screens/slot_scrub.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+Widget _app(Widget home, {double scale = 1}) => MaterialApp(
+      locale: const Locale('en'),
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      theme: buildTheme(Brightness.light),
+      builder: (c, child) => MediaQuery(
+        data: MediaQuery.of(c).copyWith(textScaler: TextScaler.linear(scale)),
+        child: child!,
+      ),
+      home: home,
+    );
+
+void _phone(WidgetTester t, double h) {
+  t.view.physicalSize = Size(390 * 3, h * 3);
+  t.view.devicePixelRatio = 3;
+  addTearDown(t.view.reset);
+}
+
+List<String> _spoken(WidgetTester t) {
+  final out = <String>[];
+  void walk(SemanticsNode n) {
+    final d = n.getSemanticsData();
+    for (final s in [d.label, d.value]) {
+      if (s.isNotEmpty) out.add(s);
+    }
+    n.visitChildren((c) {
+      walk(c);
+      return true;
+    });
+  }
+
+  walk(t.binding.renderViews.first.owner!.semanticsOwner!.rootSemanticsNode!);
+  return out;
+}
+
+void main() {
+  setUp(() => ClockFormatController.seed(ClockFormat.h24));
+  tearDown(ClockFormatController.debugReset);
+
+  group('ChartPanel', () {
+    testWidgets('a statistic with no value is spoken as No record (finding 2)',
+        (t) async {
+      final h = t.ensureSemantics();
+      _phone(t, 800);
+      await t.pumpWidget(_app(Scaffold(
+        body: ChartPanel(
+          time: 'Mon 3',
+          scrubbed: false,
+          color: Colors.red,
+          cells: const [ChartPanelCell('Resting heart rate', value: '55 bpm')],
+          stats: const [
+            ChartPanelCell('7-day avg', value: '54 bpm'),
+            ChartPanelCell('vs avg'),
+          ],
+        ),
+      )));
+      final said = _spoken(t);
+      expect(said, contains('7-day avg 54 bpm'));
+      expect(said, contains('vs avg No record'));
+      h.dispose();
+    });
+
+    testWidgets('no cells: nothing drawn, nothing thrown (finding 3)',
+        (t) async {
+      _phone(t, 800);
+      await t.pumpWidget(_app(Scaffold(
+        body: ChartPanel(
+            time: null, scrubbed: false, color: Colors.red, cells: const []),
+      )));
+      expect(t.takeException(), isNull);
+    });
+
+    testWidgets('a cell with no colour can reserve the swatch (finding 6)',
+        (t) async {
+      _phone(t, 800);
+      Future<double> labelWidth(ChartPanelCell cell) async {
+        await t.pumpWidget(_app(Scaffold(
+          body: ChartPanel(
+              time: 'x', scrubbed: false, color: Colors.red, cells: [cell]),
+        )));
+        return t.getSize(find.text('Recovery')).width;
+      }
+
+      final painted = await labelWidth(
+          const ChartPanelCell('Recovery', color: Colors.green, value: '70'));
+      final missing = await labelWidth(
+          const ChartPanelCell('Recovery', reserveSwatch: true));
+      expect(missing, painted);
+    });
+  });
+
+  group('SlotScrub', () {
+    testWidgets('an empty series builds with an empty panel (finding 10)',
+        (t) async {
+      _phone(t, 800);
+      var built = 0;
+      await t.pumpWidget(_app(Scaffold(
+        body: SlotScrub(
+          series: const [],
+          anchor: DateTime(2026, 5, 20),
+          bars: true,
+          label: 'Load',
+          color: Colors.red,
+          format: (v) => '$v',
+          builder: (c, pick, scrub, panel) {
+            built++;
+            return panel;
+          },
+        ),
+      )));
+      expect(t.takeException(), isNull);
+      expect(built, greaterThan(0));
+      expect(find.text('—'), findsOneWidget);
+    });
+  });
+
+  group('Recovery history', () {
+    final anchor = DateTime.now().subtract(const Duration(days: 3));
+    ReadinessData data(List<double?> s) => ReadinessData(
+          readiness: const Metric(
+              value: 20, unit: '', confidence: .8, tier: MetricTier.estimate),
+          series: s,
+          anchor: anchor,
+        );
+    final series = <double?>[for (var i = 0; i < 20; i++) 50, 80, 20];
+
+    Future<void> open(WidgetTester t, ReadinessData d) async {
+      _phone(t, 2400);
+      await t.pumpWidget(_app(ReadinessDetail(data: d)));
+      await t.pumpAndSettle();
+    }
+
+    final strip = find.byWidgetPredicate(
+        (w) => w is Scrubber && w.label == 'Recovery');
+
+    testWidgets('dates are the series\' own, three days back (finding 5)',
+        (t) async {
+      await open(t, data(series));
+      final l = AppLocalizations.of(t.element(find.byType(ReadinessDetail)))!;
+      final then = dayNavLabel(dayLabelOf(anchor), l);
+      final panel = find.byKey(const ValueKey('chart-panel'));
+      expect(find.descendant(of: panel, matching: find.text('LATEST · $then')),
+          findsOneWidget);
+      final says = t.widget<Scrubber>(strip).describe(.999);
+      expect(says, startsWith(prettyDay(dayLabelOf(anchor), l)));
+      final frame = t.widget<ChartFrame>(find
+          .byWidgetPredicate((w) => w is ChartFrame && w.title == 'Recovery'));
+      expect(frame.xLabels.last, isNot('Today'));
+      expect(frame.xLabels.first, '24 days ago',
+          reason: '21 slots behind the anchor, which is 3 days behind today');
+    });
+
+    testWidgets('a missing day keeps the label width a scored day has '
+        '(finding 6)', (t) async {
+      final s = <double?>[for (var i = 0; i < 20; i++) 50, 80, null];
+      await open(t, data(s));
+      double width() => t
+          .getSize(find.descendant(
+              of: find.byKey(const ValueKey('chart-panel')),
+              matching: find.text('Recovery')))
+          .width;
+      double height() =>
+          t.getSize(find.byKey(const ValueKey('chart-panel'))).height;
+      final scored = width();
+      final scoredHeight = height();
+      await t.tapAt(t.getBottomRight(strip) - const Offset(1, 1));
+      await t.pumpAndSettle();
+      expect(width(), scored);
+      // The point of the reserved swatch: the panel, and everything below it,
+      // stays put when scrubbing onto a missing day.
+      expect(height(), scoredHeight);
+    });
+  });
+
+  group('device staging', () {
+    test('a gap between epochs is an unobserved boundary (finding 7)', () {
+      final h = vendorHypnogram(const [
+        VendorEpoch(0, 30, 'light'),
+        VendorEpoch(30, 60, 'deep'),
+        VendorEpoch(90, 120, 'rem'),
+      ], 150);
+      expect(h, [
+        {'t': 0, 'stage': 'light'},
+        {'t': 30, 'stage': 'deep'},
+        {'t': 60, 'stage': 'unobserved'},
+        {'t': 90, 'stage': 'rem'},
+        {'t': 120, 'stage': 'unobserved'},
+        {'t': 150, 'stage': 'unobserved'},
+      ]);
+      final night = {'hypnogram': h};
+      expect(SleepData.stageAt(night, 45), (true, SleepStage.deep));
+      expect(SleepData.stageAt(night, 75), (true, null));
+      expect(SleepData.stageAt(night, 100), (true, SleepStage.rem));
+    });
+
+    test('back-to-back epochs add nothing', () {
+      expect(
+          vendorHypnogram(const [
+            VendorEpoch(0, 30, 'light'),
+            VendorEpoch(30, 60, 'deep'),
+          ], 60),
+          [
+            {'t': 0, 'stage': 'light'},
+            {'t': 30, 'stage': 'deep'},
+            {'t': 60, 'stage': 'deep'},
+          ]);
+    });
+  });
+
+  group('sleep charts', () {
+    final onset = DateTime(2026, 5, 19, 23).millisecondsSinceEpoch ~/ 1000;
+    final wake = DateTime(2026, 5, 20, 7).millisecondsSinceEpoch ~/ 1000;
+    final timeline = {
+      'hr': [
+        {'t': onset, 'v': 50},
+        {'t': onset + 14400, 'v': 58},
+        {'t': wake, 'v': 66},
+      ],
+      'resp': [
+        {'t': onset + 14400, 'v': 17.5},
+      ],
+    };
+    Map<String, Object?> night({bool staged = true}) => {
+          'duration_min': 360,
+          'in_bed_min': 480,
+          'efficiency': .75,
+          'onset_ts': onset,
+          'wake_ts': wake,
+          if (staged)
+            'hypnogram': [
+              {'t': onset, 'stage': 'light'},
+              {'t': onset + 3600, 'stage': 'deep'},
+              {'t': wake, 'stage': 'deep'},
+            ],
+        };
+
+    Finder plot(String label) =>
+        find.byWidgetPredicate((w) => w is Scrubber && w.label == label);
+
+    Future<void> open(WidgetTester t, SleepData d) async {
+      _phone(t, 6200);
+      await t.pumpWidget(_app(SleepDetail(data: d)));
+      await t.pumpAndSettle();
+      expect(t.takeException(), isNull);
+    }
+
+    testWidgets('a night with no staging speaks the time and the signals, '
+        'never "not measured" (finding 9)', (t) async {
+      await open(
+          t,
+          SleepData(
+              day: '2026-05-20', night: night(staged: false), timeline: timeline));
+      final says = t.widget<Scrubber>(plot('Through the night')).describe(.5);
+      expect(says, '03:00, Heart rate 58 bpm, Breathing 17.5 br/min');
+    });
+
+    testWidgets('a device with other bounds shares one instant with the '
+        'signals chart (finding 8)', (t) async {
+      final device = {
+        'device_id': 'dev-1',
+        'label': 'Ring',
+        'family': 'colmi',
+        // Two hours later than ours at the far end: its midpoint is 04:00.
+        'onset_ts': onset,
+        'wake_ts': wake + 7200,
+        'duration_min': 560,
+        'stage_min': {'light': 300, 'deep': 200},
+        'hypnogram': [
+          {'t': onset, 'stage': 'light'},
+          {'t': onset + 3600, 'stage': 'deep'},
+          {'t': wake + 7200, 'stage': 'deep'},
+        ],
+      };
+      await open(
+          t,
+          SleepData(
+              day: '2026-05-20',
+              night: night(),
+              timeline: timeline,
+              deviceNights: [device]));
+      await t.tap(find.text('Ring'));
+      await t.pumpAndSettle();
+      final rect = t.getRect(plot('Hypnogram'));
+      await t.tapAt(Offset(rect.left + rect.width * .5, rect.center.dy));
+      await t.pumpAndSettle();
+      // 05 h into a 10 h device night is 04:00, which is 5/8 of ours.
+      expect(t.widget<Scrubber>(plot('Hypnogram')).value, closeTo(.5, .01));
+      expect(t.widget<Scrubber>(plot('Through the night')).value,
+          closeTo(5 / 8, .01));
+      final panels = find.byKey(const ValueKey('chart-panel'));
+      for (var i = 0; i < 2; i++) {
+        expect(
+            find.descendant(
+                of: panels.at(i), matching: find.text('SELECTED · 04:00')),
+            findsOneWidget,
+            reason: 'panel $i');
+      }
+    });
+  });
+}
diff --git a/test/graphs_scroll_first_scrub_test.dart b/test/graphs_scroll_first_scrub_test.dart
new file mode 100644
index 000000000..d9b298ff9
--- /dev/null
+++ b/test/graphs_scroll_first_scrub_test.dart
@@ -0,0 +1,267 @@
+// SCROLL FIRST, SCRUB DELIBERATELY (Graphs PR, red tests).
+//
+// WHY: a thumb that starts a page scroll on top of a chart must not drag the
+// chart's marker. Upstream's `Scrubber` is a bare `Listener` that moves the
+// marker on every pointer-down and pointer-move, and a `Listener` never joins
+// the gesture arena, so the page scrolls AND the marker jumps. The intended
+// behaviour (the fork's APK1 batch, bf016f7e / 11744b52 / a893e511):
+//   * pointer-down alone selects nothing;
+//   * a mostly-vertical move belongs to the page: no marker, page scrolls;
+//   * a horizontal-dominant move (more than 1.5x the vertical) past the DEVICE
+//     touch slop belongs to the chart: marker follows, page does not move;
+//   * a tap selects on release; a long press selects and then follows the
+//     finger on any axis;
+//   * the recognizers use the device's touch slop, not the 18 pt default.
+//
+// Two production charts are driven (metric detail trend, sleep hypnogram) plus
+// the bare Scrubber in a ListView for the slop law.
+import 'package:flutter/gestures.dart' show DeviceGestureSettings;
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/ui2/screens/screens.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+final _onset = DateTime(2026, 5, 19, 23).millisecondsSinceEpoch ~/ 1000;
+final _wake = DateTime(2026, 5, 20, 7).millisecondsSinceEpoch ~/ 1000;
+
+SleepData _sleep() => SleepData(
+      day: '2026-05-20',
+      night: {
+        'duration_min': 420,
+        'in_bed_min': 480,
+        'awake_min': 15,
+        'efficiency': .88,
+        'onset_ts': _onset,
+        'wake_ts': _wake,
+        'light_min': 200,
+        'deep_min': 120,
+        'rem_min': 100,
+        'hypnogram': [
+          {'t': _onset, 'stage': 'light'},
+          {'t': _onset + 3600, 'stage': 'deep'},
+          {'t': _onset + 10800, 'stage': 'rem'},
+          {'t': _wake, 'stage': 'awake'},
+        ],
+      },
+    );
+
+MetricData _metric() {
+  final n = DateTime.now();
+  return MetricData(daysAvailable: 10, series: [
+    for (var back = 9; back >= 0; back--)
+      (
+        t: DateTime(n.year, n.month, n.day - back, 12).millisecondsSinceEpoch ~/
+            1000,
+        v: 50.0 + back,
+      ),
+  ]);
+}
+
+class _Rig {
+  const _Rig(this.name, this.mount, this.plot);
+  final String name;
+  final Future<void> Function(WidgetTester t, double scale) mount;
+  final Finder Function() plot;
+}
+
+void _phone(WidgetTester t, double h) {
+  t.view.physicalSize = Size(390 * 3, h * 3);
+  t.view.devicePixelRatio = 3;
+  addTearDown(t.view.reset);
+}
+
+Widget _scaled(double scale, Widget home) => MaterialApp(
+      theme: buildTheme(Brightness.light),
+      builder: (c, child) => MediaQuery(
+        data: MediaQuery.of(c).copyWith(textScaler: TextScaler.linear(scale)),
+        child: child!,
+      ),
+      home: home,
+    );
+
+final _rigs = <_Rig>[
+  _Rig(
+    'metric detail trend',
+    (t, scale) async {
+      _phone(t, 640);
+      await t.pumpWidget(_scaled(
+          scale, Scaffold(body: MetricDetail('resting_hr', data: _metric()))));
+      await t.pumpAndSettle();
+      await t.tap(find.text('7 days'));
+      await t.pumpAndSettle();
+    },
+    () => find.descendant(
+        of: find.byType(ChartFrame).first, matching: find.byType(Scrubber)),
+  ),
+  _Rig(
+    'sleep hypnogram',
+    (t, scale) async {
+      _phone(t, 640);
+      await t.pumpWidget(_scaled(scale, SleepDetail(data: _sleep())));
+      await t.pumpAndSettle();
+    },
+    () => find.byWidgetPredicate(
+        (w) => w is Scrubber && w.label == 'Hypnogram'),
+  ),
+];
+
+Finder get _verticalScroll => find.byWidgetPredicate(
+    (w) => w is Scrollable && w.axis == Axis.vertical);
+
+Future<ScrollPosition> _mount(WidgetTester t, _Rig r, double scale) async {
+  await r.mount(t, scale);
+  final plot = r.plot();
+  expect(plot, findsOneWidget, reason: '${r.name}: the chart is on screen');
+  await t.ensureVisible(plot);
+  await t.pumpAndSettle();
+  expect(t.widget<Scrubber>(plot).value, isNull,
+      reason: 'nothing is selected before a touch');
+  final scroll = t
+      .state<ScrollableState>(
+          find.ancestor(of: plot, matching: _verticalScroll).first)
+      .position;
+  expect(scroll.maxScrollExtent, greaterThan(100),
+      reason: 'a real scrollable page, not a chart in an unscrollable box');
+  expect(t.takeException(), isNull, reason: '${r.name} lays out at $scale');
+  return scroll;
+}
+
+/// Brings the chart back on screen without touching it (a drag can carry it off
+/// and rebuild a lazy item), then reads the marker.
+Future<double?> _marker(WidgetTester t, _Rig r) async {
+  await t.ensureVisible(r.plot());
+  await t.pumpAndSettle();
+  return t.widget<Scrubber>(r.plot()).value;
+}
+
+void main() {
+  for (final r in _rigs) {
+    for (final scale in [1.0, 2.0]) {
+      testWidgets(
+          '${r.name}: a mostly vertical drag on the chart scrolls the page '
+          'and never moves the marker (x$scale)', (t) async {
+        final scroll = await _mount(t, r, scale);
+        final before = scroll.pixels;
+        final dy = scroll.extentAfter > 150 ? -130.0 : 130.0;
+        await t.timedDrag(
+            r.plot(), Offset(12, dy), const Duration(milliseconds: 350));
+        await t.pumpAndSettle();
+        expect((scroll.pixels - before).abs(), greaterThan(40),
+            reason: 'a vertical drag that begins on the chart belongs to the page');
+        expect(await _marker(t, r), isNull,
+            reason: 'neither pointer-down nor a vertical move may scrub');
+        expect(t.takeException(), isNull);
+      });
+
+      testWidgets(
+          '${r.name}: a first move of 24 across and 60 down scrolls without '
+          'selecting (x$scale)', (t) async {
+        final scroll = await _mount(t, r, scale);
+        final before = scroll.pixels;
+        final dy = scroll.extentAfter > 150 ? -60.0 : 60.0;
+        final g = await t.startGesture(t.getCenter(r.plot()));
+        // One event crosses BOTH slops, so the dominance check decides, not
+        // whichever axis happened to cross first.
+        await g.moveBy(Offset(24, dy));
+        await t.pump();
+        expect(t.widget<Scrubber>(r.plot()).value, isNull);
+        await g.moveBy(Offset(0, dy));
+        await g.up();
+        await t.pumpAndSettle();
+        expect((scroll.pixels - before).abs(), greaterThan(40));
+        expect(await _marker(t, r), isNull);
+        expect(t.takeException(), isNull);
+      });
+
+      testWidgets(
+          '${r.name}: pointer-down alone selects nothing; a horizontal drag '
+          'past slop scrubs and the page stays put (x$scale)', (t) async {
+        final scroll = await _mount(t, r, scale);
+        final before = scroll.pixels;
+        final pending = await t.startGesture(t.getCenter(r.plot()));
+        await t.pump();
+        expect(t.widget<Scrubber>(r.plot()).value, isNull,
+            reason: 'an unresolved pointer-down must not flash a marker '
+                'during what may be a page scroll');
+        await pending.up();
+        await t.pump();
+        // A few points of vertical noise must not turn a deliberate sideways
+        // scrub into a page scroll.
+        await t.drag(r.plot(), const Offset(60, 5));
+        await t.pumpAndSettle();
+        expect(scroll.pixels, closeTo(before, 1),
+            reason: 'a horizontal-dominant drag does not scroll the page');
+        expect(t.widget<Scrubber>(r.plot()).value, isNotNull,
+            reason: 'the chart took the drag');
+        expect(t.takeException(), isNull);
+      });
+
+      testWidgets(
+          '${r.name}: a long press then a vertical drag selects without '
+          'scrolling (x$scale)', (t) async {
+        final scroll = await _mount(t, r, scale);
+        final before = scroll.pixels;
+        final g = await t.startGesture(t.getCenter(r.plot()));
+        await t.pump(const Duration(milliseconds: 700));
+        await g.moveBy(const Offset(0, 40));
+        await t.pump();
+        expect(t.widget<Scrubber>(r.plot()).value, isNotNull,
+            reason: 'a held finger is a deliberate scrub on any axis');
+        expect(scroll.pixels, closeTo(before, 1));
+        await g.up();
+        await t.pumpAndSettle();
+        expect(t.takeException(), isNull);
+      });
+
+      testWidgets('${r.name}: a tap still places the marker (x$scale)',
+          (t) async {
+        await _mount(t, r, scale);
+        await t.tapAt(t.getCenter(r.plot()));
+        await t.pumpAndSettle();
+        expect(t.widget<Scrubber>(r.plot()).value, closeTo(.5, .1));
+      });
+    }
+  }
+
+  // The recognizers must take the DEVICE's touch slop, as GestureDetector
+  // does. With an 8 pt device slop and the 18 pt default, a gradual
+  // horizontal-dominant drag would lose to the page scroll at 9 pt.
+  testWidgets('with an 8 pt device slop a gradual horizontal-dominant drag '
+      'scrubs instead of scrolling', (t) async {
+    final picked = ValueNotifier<double?>(null);
+    await t.pumpWidget(MaterialApp(
+      home: MediaQuery(
+        data: const MediaQueryData(
+            size: Size(360, 800),
+            gestureSettings: DeviceGestureSettings(touchSlop: 8)),
+        child: Scaffold(
+          body: ListView(children: [
+            const SizedBox(height: 200),
+            ValueListenableBuilder<double?>(
+              valueListenable: picked,
+              builder: (_, v, _) => Scrubber(
+                value: v,
+                onChanged: (x) => picked.value = x,
+                label: 'Chart',
+                describe: (x) => x.toStringAsFixed(2),
+                child: const SizedBox(height: 160, width: 360),
+              ),
+            ),
+            const SizedBox(height: 2000),
+          ]),
+        ),
+      ),
+    ));
+    final scroll = t.state<ScrollableState>(find.byType(Scrollable)).position;
+    final g = await t.startGesture(t.getCenter(find.byType(Scrubber)));
+    // Small steps, each 14:9 (horizontal dominant by more than 1.5x).
+    for (var i = 0; i < 6; i++) {
+      await g.moveBy(const Offset(14 / 3, 3));
+      await t.pump();
+    }
+    await g.up();
+    await t.pump();
+    expect(picked.value, isNotNull, reason: 'the scrubber won the arena');
+    expect(scroll.pixels, 0, reason: 'the page did not scroll');
+  });
+}
diff --git a/test/graphs_scrub_health_hrv_test.dart b/test/graphs_scrub_health_hrv_test.dart
new file mode 100644
index 000000000..dd73e4eb7
--- /dev/null
+++ b/test/graphs_scrub_health_hrv_test.dart
@@ -0,0 +1,80 @@
+// SCRUB + PANEL ON THE HEALTH HRV CHART (Graphs PR phase 5, red tests).
+//
+// The Vitals tab's "Heart rate variability" deep-dive card draws thirty nights
+// of RMSSD as a line, with no scrub at all on upstream, and the whole card is a
+// tap target that opens Investigate. The fork made this chart scroll-first
+// scrubbable (87f9654f). The chart must read a night under the finger without
+// the card navigating, and the page must still scroll from the chart.
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/ui2/screens/screens.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+import 'support/scrub_surface_laws.dart';
+
+const _nights = 30, _gapBack = 3, _scrubbedBack = 10;
+
+/// RMSSD of 80 - back on every night except a hole at [_gapBack]; noon local
+/// on each calendar day.
+HealthData _data() {
+  final n = DateTime.now();
+  return HealthData(charts: {
+    'hrv': [
+      for (var back = _nights - 1; back >= 0; back--)
+        if (back != _gapBack)
+          (
+            t: DateTime(n.year, n.month, n.day - back, 12)
+                    .millisecondsSinceEpoch ~/
+                1000,
+            v: 80.0 - back,
+          ),
+    ],
+  });
+}
+
+Future<void> _mount(WidgetTester t, double scale) async {
+  phone(t, 390, 640);
+  await t.pumpWidget(scaledApp(
+      scale,
+      Scaffold(
+          body: HealthScreen(
+        data: _data(),
+        vitals: const VitalsData(day: '2026-01-01', days: ['2026-01-01'], hrv: {'rmssd': 80}),
+        tab: 3,
+      ))));
+  await t.pumpAndSettle();
+  // Controls: the card and its chart frame are on screen.
+  expect(find.text('Heart rate variability'), findsWidgets);
+  expect(find.byType(ChartFrame), findsOneWidget);
+}
+
+void main() {
+  final rig = SurfaceRig(
+    name: 'health HRV',
+    mount: _mount,
+    plot: () => find.descendant(
+        of: find.byType(ChartFrame), matching: find.byType(Scrubber)),
+    slots: _nights,
+    bars: false,
+    scrubbed: _nights - 1 - _scrubbedBack,
+    gap: _nights - 1 - _gapBack,
+    lastWord: 'last night',
+    valueAt: (slot) => '^${(80 - (_nights - 1 - slot))}ms',
+  );
+  defineSurfaceLaws(rig);
+
+  testWidgets('a tap on the chart reads a night and does not open the card',
+      (t) async {
+    await _mount(t, 1);
+    final plot = rig.plot();
+    expect(plot, findsOneWidget, reason: 'the chart has no Scrubber');
+    await t.ensureVisible(plot);
+    await t.pumpAndSettle();
+    await t.tapAt(t.getCenter(plot));
+    await t.pumpAndSettle();
+    expect(t.widget<Scrubber>(plot).value, isNotNull);
+    expect(find.byType(HealthScreen), findsOneWidget,
+        reason: 'the card navigates only from outside the chart');
+    expect(find.text('Heart rate variability'), findsWidgets);
+  });
+}
diff --git a/test/graphs_scrub_month_grid_test.dart b/test/graphs_scrub_month_grid_test.dart
new file mode 100644
index 000000000..65f06aa29
--- /dev/null
+++ b/test/graphs_scrub_month_grid_test.dart
@@ -0,0 +1,163 @@
+// SCRUB + PANEL ON THE MONTH GRID (Graphs PR phase 5, red tests).
+//
+// Each shaded row of the month grid is a 30-cell strip: where the day sat
+// against the person's usual range. Upstream has no way to read one cell. The
+// fork's strip scrubbed (ChartScrub, nearest cell) with a key row naming the
+// day's side. The panel reads "Above usual / Normal for you / Below usual"
+// for the selected day, a dash for a day with no value, and a row that is not
+// shaded (too little history) has neither a strip to scrub nor a panel.
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/ui2/screens/metric_detail.dart' show specOf;
+import 'package:openstrap_edge/ui2/screens/month_grid.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+import 'support/scrub_surface_laws.dart';
+
+/// Oldest first, slot 29 is today. Slot i is below / inside / above by i % 3,
+/// except slot 27, which has no value.
+const _gapSlot = 27, _scrubSlot = 13; // 13 % 3 == 1 -> inside
+
+Side? _side(int i) =>
+    i == _gapSlot ? null : Side.values[(i % 3 == 0 ? 2 : (i % 3 == 1 ? 0 : 1))];
+
+String _word(int slot) => switch (_side(slot)) {
+      Side.inside => 'Normalforyou',
+      Side.above => 'Aboveusual',
+      Side.below => 'Belowusual',
+      null => '—',
+    };
+
+GridRow _row(String key, {int history = 40}) => GridRow(
+      spec: specOf(key),
+      key: key,
+      cells: [for (var i = 0; i < kGridDays; i++) _side(i)],
+      have: kGridDays - 1,
+      historyDays: history,
+      ranged: true,
+      anchor: DateTime.now(),
+    );
+
+/// A page with room to scroll above and below the grid.
+Widget _page(List<GridRow> rows, {bool sideways = false}) {
+  Widget grid = MonthGrid(rows);
+  if (sideways) {
+    grid = SingleChildScrollView(
+      key: const ValueKey('sideways'),
+      scrollDirection: Axis.horizontal,
+      child: SizedBox(width: 800, child: grid),
+    );
+  }
+  return Scaffold(
+    body: ListView(children: [
+      const SizedBox(height: 300),
+      grid,
+      const SizedBox(height: 900),
+    ]),
+  );
+}
+
+Future<void> _mount(WidgetTester t, double scale) async {
+  phone(t, 390, 640);
+  await t.pumpWidget(scaledApp(scale, _page([_row('readiness')])));
+  await t.pumpAndSettle();
+  // Controls: the grid is drawn.
+  expect(find.text('Today'), findsOneWidget);
+}
+
+void main() {
+  final rig = SurfaceRig(
+    name: 'month grid',
+    mount: _mount,
+    plot: () => find.byType(Scrubber),
+    slots: kGridDays,
+    bars: true,
+    scrubbed: _scrubSlot,
+    gap: _gapSlot,
+    valueAt: (slot) => '^${_word(slot)}',
+  );
+  defineSurfaceLaws(rig);
+
+  testWidgets('every shaded row has its own strip and its own panel',
+      (t) async {
+    phone(t, 390, 1200);
+    await t.pumpWidget(scaledApp(
+        1, _page([_row('sleep'), _row('readiness'), _row('strain')])));
+    await t.pumpAndSettle();
+    expect(find.byType(Scrubber), findsNWidgets(3));
+    expect(find.byKey(panelKey), findsNWidgets(3));
+  });
+
+  testWidgets('a row without enough history draws no strip to scrub and no '
+      'panel: nothing is invented', (t) async {
+    phone(t, 390, 900);
+    final waiting = GridRow(
+      spec: specOf('sleep'),
+      key: 'sleep',
+      cells: List<Side?>.filled(kGridDays, null),
+      have: 3,
+      historyDays: 3,
+      ranged: false,
+      anchor: DateTime.now(),
+    );
+    await t.pumpWidget(scaledApp(1, _page([waiting, _row('readiness')])));
+    await t.pumpAndSettle();
+    expect(find.byType(Scrubber), findsOneWidget,
+        reason: 'only the shaded row scrubs');
+    expect(find.byKey(panelKey), findsOneWidget);
+  });
+
+  group('inside a horizontal scroller', () {
+    testWidgets('a vertical drag on the strip still scrolls the page and '
+        'selects nothing', (t) async {
+      phone(t, 390, 640);
+      await t.pumpWidget(scaledApp(1, _page([_row('readiness')], sideways: true)));
+      await t.pumpAndSettle();
+      final strip = find.byType(Scrubber);
+      expect(strip, findsOneWidget, reason: 'the strip has no Scrubber');
+      final page = t
+          .state<ScrollableState>(find
+              .byWidgetPredicate(
+                  (w) => w is Scrollable && w.axis == Axis.vertical)
+              .first)
+          .position;
+      final before = page.pixels;
+      // The strip is 800 wide in a 390 viewport: touch inside the viewport.
+      final box = t.getRect(strip);
+      await t.timedDragFrom(Offset(100, box.center.dy),
+          const Offset(10, -120), const Duration(milliseconds: 350));
+      await t.pumpAndSettle();
+      expect(page.pixels - before, greaterThan(40));
+      expect(t.widget<Scrubber>(strip).value, isNull);
+    });
+
+    testWidgets('the scroller still moves from outside the strip, and the '
+        'page does not', (t) async {
+      phone(t, 390, 640);
+      await t.pumpWidget(scaledApp(1, _page([_row('readiness')], sideways: true)));
+      await t.pumpAndSettle();
+      // Control for the Scrubber, so this cannot pass on an unchanged grid and
+      // then be broken by the change.
+      expect(find.byType(Scrubber), findsOneWidget,
+          reason: 'the strip has no Scrubber');
+      final side = t
+          .state<ScrollableState>(find
+              .descendant(
+                  of: find.byKey(const ValueKey('sideways')),
+                  matching: find.byType(Scrollable))
+              .first)
+          .position;
+      final page = t
+          .state<ScrollableState>(find
+              .byWidgetPredicate(
+                  (w) => w is Scrollable && w.axis == Axis.vertical)
+              .first)
+          .position;
+      final pageBefore = page.pixels;
+      await t.drag(find.text('29 days ago'), const Offset(-120, 4));
+      await t.pumpAndSettle();
+      expect(side.pixels, greaterThan(40));
+      expect(page.pixels, closeTo(pageBefore, 1));
+    });
+  });
+}
diff --git a/test/graphs_scrub_panel_test.dart b/test/graphs_scrub_panel_test.dart
new file mode 100644
index 000000000..a755b3b70
--- /dev/null
+++ b/test/graphs_scrub_panel_test.dart
@@ -0,0 +1,719 @@
+// THE ALWAYS-PRESENT SCRUB PANEL (Graphs PR, red tests).
+//
+// WHY: when you stop on a time, an inset panel under the chart reads every
+// series at that instant. Idle it says LATEST (the newest reading, or the
+// stage at wake on a night); touched it says SELECTED. Upstream shows a
+// pop-in row only WHILE a finger is down (`MetricDetail._picked`,
+// `SleepDetail._scrubCard`), so the chart jumps in height under the thumb and
+// nothing is readable at rest. The panel contract (owner decision 2026-10-22,
+// ported from the fork's support/scrub_panel_laws.dart) uses ValueKeys:
+//   chart-panel          the inset box: card2 fill, rMd radius, no shadow,
+//                        no visible border at rest, a border in the series
+//                        colour while scrubbing. Fixed rect.
+//   chart-panel-caption  Text 'LATEST · <day|time>' / 'SELECTED · <day|time>',
+//                        in the series colour while scrubbing.
+//   chart-panel-value    the big value + unit; '—' where nothing was recorded.
+//   chart-panel-stat:<id> a secondary stat of the one series.
+// Spoken form: the slider says the selected instant ONCE; the panel adds only
+// what the slider does not (the stats, 'label value'), and a day with a value
+// offers an 'Open <day>' action of at least 48 dp.
+import 'package:flutter/material.dart';
+import 'package:flutter/semantics.dart' show SemanticsNode;
+import 'package:flutter_test/flutter_test.dart';
+import 'package:lucide_icons_flutter/lucide_icons.dart';
+import 'package:openstrap_edge/l10n/app_localizations.dart';
+import 'package:openstrap_edge/state/clock_format.dart';
+import 'package:openstrap_edge/ui2/screens/screens.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+const _panelKey = ValueKey('chart-panel');
+const _captionKey = ValueKey('chart-panel-caption');
+const _valueKey = ValueKey('chart-panel-value');
+
+String _plain(Text x) => x.data ?? x.textSpan?.toPlainText() ?? '';
+
+Widget _scaled(double scale, Widget home, {Brightness b = Brightness.light}) =>
+    MaterialApp(
+      locale: const Locale('en'),
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      theme: buildTheme(b),
+      builder: (c, child) => MediaQuery(
+        data: MediaQuery.of(c).copyWith(textScaler: TextScaler.linear(scale)),
+        child: child!,
+      ),
+      home: home,
+    );
+
+void _phone(WidgetTester t, double w, double h) {
+  t.view.physicalSize = Size(w * 3, h * 3);
+  t.view.devicePixelRatio = 3;
+  addTearDown(t.view.reset);
+}
+
+/// Every string a screen reader could be given, from the whole tree.
+List<String> _spoken(WidgetTester t) {
+  final out = <String>[];
+  void walk(SemanticsNode n) {
+    final d = n.getSemanticsData();
+    for (final s in [d.label, d.value, d.increasedValue, d.decreasedValue]) {
+      if (s.isNotEmpty) out.add(s);
+    }
+    n.visitChildren((c) {
+      walk(c);
+      return true;
+    });
+  }
+
+  walk(t.binding.renderViews.first.owner!.semanticsOwner!.rootSemanticsNode!);
+  return out;
+}
+
+int _times(WidgetTester t, String what) =>
+    _spoken(t).where((s) => s.contains(what)).length;
+
+/// Whether [caption] names [back] days ago: the weekday and the day of the
+/// month, or 'today' / 'yesterday' where the chart words it so.
+bool _namesDay(String caption, int back) {
+  final c = caption.toLowerCase();
+  final n = DateTime.now();
+  final d = DateTime(n.year, n.month, n.day - back);
+  const wd = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+  if (back == 0 && c.contains('today')) return true;
+  if (back == 1 && c.contains('yesterday')) return true;
+  return c.contains(wd[d.weekday - 1]) && RegExp('\\b${d.day}\\b').hasMatch(c);
+}
+
+BoxDecoration _decoration(WidgetTester t, Finder panel) {
+  final w = t.widget(panel);
+  if (w is Container) return w.decoration! as BoxDecoration;
+  if (w is DecoratedBox) return w.decoration as BoxDecoration;
+  fail('chart-panel must be a Container or DecoratedBox, got ${w.runtimeType}');
+}
+
+int _rgb(Color c) => c.toARGB32() & 0xFFFFFF;
+
+// ═══════════════ metric detail: resting heart rate, 7 days ═══════════════
+//
+// A value of 50 + back (back = days ago, 0 = today) on every day of the
+// window except a GAP at 2 days ago.
+const _gapBack = 2, _scrubbedBack = 3;
+
+MetricData _rhr() {
+  final n = DateTime.now();
+  return MetricData(daysAvailable: 10, series: [
+    for (var back = 9; back >= 0; back--)
+      if (back != _gapBack)
+        (
+          t: DateTime(n.year, n.month, n.day - back, 12)
+                  .millisecondsSinceEpoch ~/
+              1000,
+          v: 50.0 + back,
+        ),
+  ]);
+}
+
+Future<void> _openRhr(WidgetTester t,
+    {double width = 390, double scale = 1}) async {
+  _phone(t, width, 1800);
+  await t.pumpWidget(_scaled(
+      scale, Scaffold(body: MetricDetail('resting_hr', data: _rhr()))));
+  await t.pumpAndSettle();
+  await t.tap(find.text('7 days'));
+  await t.pumpAndSettle();
+}
+
+Finder get _plot => find.descendant(
+    of: find.byType(ChartFrame).first, matching: find.byType(Scrubber));
+
+/// Taps the plot on the day [back] days ago (7 slots, the last is today).
+Future<void> _scrubBack(WidgetTester t, int back) async {
+  final r = t.getRect(_plot);
+  await t.tapAt(Offset(r.left + r.width * (6 - back) / 6, r.center.dy));
+  await t.pumpAndSettle();
+}
+
+String _valueOf(WidgetTester t, Finder panel) {
+  final f = find.descendant(of: panel, matching: find.byKey(_valueKey));
+  expect(f, findsOneWidget, reason: 'the panel has no value');
+  return [
+    for (final x in t.widgetList<Text>(
+        find.descendant(of: f, matching: find.byType(Text))))
+      _plain(x)
+  ].join().replaceAll(RegExp(r'\s+'), '');
+}
+
+String _captionOf(WidgetTester t, Finder panel) {
+  final f = find.descendant(of: panel, matching: find.byKey(_captionKey));
+  expect(f, findsOneWidget, reason: 'the panel has no caption');
+  return _plain(t.widget<Text>(f));
+}
+
+void main() {
+  setUp(() => ClockFormatController.seed(ClockFormat.h24));
+  tearDown(ClockFormatController.debugReset);
+
+  group('metric detail panel', () {
+    testWidgets('at rest: one panel, LATEST, today, the value and unit, the '
+        'stats', (t) async {
+      await _openRhr(t);
+      final panel = find.byKey(_panelKey);
+      expect(panel, findsOneWidget, reason: 'no panel at rest');
+      final cap = _captionOf(t, panel);
+      expect(cap.toLowerCase(), startsWith('latest'));
+      expect(_namesDay(cap, 0), isTrue, reason: 'caption "$cap" names no day');
+      expect(_valueOf(t, panel), '50bpm');
+      final stats = find.descendant(
+          of: panel,
+          matching: find.byWidgetPredicate((w) =>
+              w.key is ValueKey<String> &&
+              (w.key! as ValueKey<String>).value.startsWith('chart-panel-stat:')));
+      expect(stats, findsAtLeastNWidgets(2), reason: '7-day avg and vs avg');
+      final texts = [
+        for (final x in t.widgetList<Text>(
+            find.descendant(of: stats, matching: find.byType(Text))))
+          _plain(x).replaceAll(RegExp(r'\s+'), ' ')
+      ];
+      // Days 6,5,4,3,1,0 ago read 56,55,54,53,51,50: mean 53.17.
+      expect(texts, contains('53 bpm'));
+      expect(texts.where((s) => RegExp(r'^[+\-−]3 bpm$').hasMatch(s)),
+          isNotEmpty,
+          reason: 'vs avg for the latest day (50 against 53.17)');
+    });
+
+    testWidgets('scrubbing: SELECTED, the scrubbed day, its value, a border in '
+        'the series colour', (t) async {
+      await _openRhr(t);
+      final panel = find.byKey(_panelKey);
+      expect(panel, findsOneWidget, reason: 'no panel at rest');
+      final rest = _decoration(t, panel).border;
+      expect(rest == null || rest.top.width == 0 || rest.top.color.a == 0,
+          isTrue,
+          reason: 'no visible border at rest');
+      await _scrubBack(t, _scrubbedBack);
+      expect(panel, findsOneWidget);
+      final cap = _captionOf(t, panel);
+      expect(cap.toLowerCase(), startsWith('selected'));
+      expect(_namesDay(cap, _scrubbedBack), isTrue,
+          reason: 'caption "$cap" is not $_scrubbedBack days back');
+      expect(_valueOf(t, panel), '53bpm');
+      final colour = _rgb(
+          P.of(t.element(panel)).on(specOf('resting_hr').color));
+      final b = _decoration(t, panel).border;
+      expect(b, isNotNull, reason: 'scrubbing draws a border');
+      expect(b!.top.width, greaterThan(0));
+      expect(_rgb(b.top.color), colour);
+      final capText = t.widget<Text>(
+          find.descendant(of: panel, matching: find.byKey(_captionKey)));
+      expect(_rgb(capText.style!.color!), colour,
+          reason: 'SELECTED is in the series colour');
+    });
+
+    testWidgets('a day with no reading says so: SELECTED and a dash, never a '
+        'neighbour\'s number', (t) async {
+      await _openRhr(t);
+      final panel = find.byKey(_panelKey);
+      expect(panel, findsOneWidget, reason: 'no panel at rest');
+      await _scrubBack(t, _gapBack);
+      expect(_captionOf(t, panel).toLowerCase(), startsWith('selected'));
+      expect(_namesDay(_captionOf(t, panel), _gapBack), isTrue);
+      expect(_valueOf(t, panel), startsWith('—'));
+    });
+
+    testWidgets('the panel and the frame keep their size and place at rest, '
+        'scrubbing, on a gap day and back on today; no pop-in row appears',
+        (t) async {
+      await _openRhr(t);
+      final panel = find.byKey(_panelKey);
+      expect(panel, findsOneWidget, reason: 'no panel at rest');
+      final rect = t.getRect(panel);
+      final frame = t.getRect(find.byType(ChartFrame).first);
+      final surfaces = find.byType(Surface).evaluate().length;
+      for (final back in [_scrubbedBack, _gapBack, 4, 0]) {
+        await _scrubBack(t, back);
+        expect(panel, findsOneWidget);
+        expect(t.getRect(panel), rect, reason: 'panel moved on day -$back');
+        expect(t.getRect(find.byType(ChartFrame).first), frame,
+            reason: 'frame moved on day -$back');
+        expect(find.byType(Surface).evaluate().length, surfaces,
+            reason: 'the old pop-in Surface must not come back (day -$back)');
+      }
+    });
+
+    testWidgets('inset style: card2 fill, rMd radius, no shadow, under the '
+        'plot and inside the card', (t) async {
+      await _openRhr(t);
+      final panel = find.byKey(_panelKey);
+      expect(panel, findsOneWidget, reason: 'no panel at rest');
+      final p = P.of(t.element(panel));
+      final d = _decoration(t, panel);
+      expect(d.color, p.card2);
+      expect(d.borderRadius, R.rMd);
+      expect(d.boxShadow, anyOf(isNull, isEmpty));
+      expect(t.getRect(panel).top, greaterThanOrEqualTo(t.getRect(_plot).bottom));
+    });
+
+    for (final w in [360.0, 390.0]) {
+      for (final s in [1.0, 1.3]) {
+        testWidgets('no overflow and no shift at width $w, text scale $s',
+            (t) async {
+          await _openRhr(t, width: w, scale: s);
+          final panel = find.byKey(_panelKey);
+          expect(panel, findsOneWidget, reason: 'no panel at rest');
+          expect(t.takeException(), isNull);
+          final rect = t.getRect(panel);
+          final box = t.getRect(find.byType(ChartFrame).first);
+          expect(rect.left, greaterThanOrEqualTo(box.left - .01));
+          expect(rect.right, lessThanOrEqualTo(box.right + .01));
+          for (final back in [_scrubbedBack, _gapBack]) {
+            await _scrubBack(t, back);
+            expect(t.takeException(), isNull);
+            expect(t.getRect(panel), rect);
+          }
+        });
+      }
+    }
+
+    testWidgets('spoken once: the slider says the selected day and value; the '
+        'panel does not repeat it and speaks the stats as "label value"',
+        (t) async {
+      final h = t.ensureSemantics();
+      await _openRhr(t);
+      await _scrubBack(t, _scrubbedBack);
+      final scrubber = t.widget<Scrubber>(_plot);
+      final said = scrubber.describe(scrubber.value!);
+      expect(said, contains('53 bpm'));
+      expect(_times(t, said), 1,
+          reason: 'the selection is voiced once across slider and panel');
+      expect(find.bySemanticsLabel(RegExp(r'^(LATEST|SELECTED)', caseSensitive: false)),
+          findsNothing,
+          reason: 'the visual caption is not a second announcement');
+      expect(_spoken(t).where((s) => RegExp(r'7-day avg.*53 bpm').hasMatch(s)),
+          hasLength(1),
+          reason: 'a stat is spoken as one "label value" node');
+      h.dispose();
+    });
+
+    testWidgets('at rest the panel speaks the LATEST day and value once; '
+        'selecting hands the reading to the slider', (t) async {
+      final h = t.ensureSemantics();
+      await _openRhr(t);
+      final latest = find.semantics.byLabel(RegExp(r'^LATEST'));
+      final said = latest.evaluate().single.label;
+      expect(said, startsWith('LATEST · Today, '));
+      expect(said, contains('50 bpm'));
+      expect(
+          t.getSemantics(find.byWidgetPredicate(
+              (w) => w is Scrubber && w.label == 'Resting heart rate')).value,
+          'Nothing selected');
+      await _scrubBack(t, _scrubbedBack);
+      expect(latest, findsNothing);
+      expect(find.semantics.byLabel(RegExp(r'^SELECTED')), findsNothing);
+      expect(
+          t.getSemantics(find.byWidgetPredicate(
+              (w) => w is Scrubber && w.label == 'Resting heart rate')).value,
+          contains('53 bpm'),
+          reason: 'the slider says the selected day and value');
+      h.dispose();
+    });
+
+    testWidgets('a day with a value offers "Open <day>" of at least 48 dp; a '
+        'day without one offers nothing to open', (t) async {
+      final h = t.ensureSemantics();
+      await _openRhr(t);
+      await _scrubBack(t, _scrubbedBack);
+      final open = find.bySemanticsLabel(RegExp(r'^Open '));
+      expect(open, findsOneWidget);
+      expect(t.getSemantics(open).rect.height, greaterThanOrEqualTo(48));
+      await _scrubBack(t, _gapBack);
+      expect(find.bySemanticsLabel(RegExp(r'^Open ')), findsNothing,
+          reason: 'an action button is a promise; an empty day has no screen');
+      h.dispose();
+    });
+
+    // A day that can be opened shows the same chevron the old pop-in row had.
+    final chevron = find.descendant(
+        of: find.byKey(_panelKey), matching: find.byIcon(LucideIcons.chevronRight));
+
+    testWidgets('a chevron shows when the day opens and not on a gap day, '
+        'and the panel keeps its size', (t) async {
+      await _openRhr(t);
+      final panel = find.byKey(_panelKey);
+      expect(chevron, findsOneWidget, reason: 'today opens, so a chevron');
+      final icon = t.widget<Icon>(chevron);
+      expect(icon.size, 18);
+      expect(icon.color, P.of(t.element(panel)).ink3);
+      final size = t.getSize(panel);
+      final cap = t.getRect(find.byKey(_captionKey));
+      await _scrubBack(t, _gapBack);
+      expect(chevron, findsNothing, reason: 'a gap day opens nothing');
+      expect(t.getSize(panel), size, reason: 'the chevron changed the height');
+      expect(t.getRect(find.byKey(_captionKey)), cap,
+          reason: 'the caption jumped');
+      await _scrubBack(t, _scrubbedBack);
+      expect(chevron, findsOneWidget);
+      expect(t.getSize(panel), size);
+    });
+
+    testWidgets('the chevron sits at the trailing edge, centred on the value '
+        'line, and is not spoken', (t) async {
+      final h = t.ensureSemantics();
+      await _openRhr(t);
+      final panel = t.getRect(find.byKey(_panelKey));
+      final c = t.getRect(chevron);
+      final value = t.getRect(find.byKey(_valueKey));
+      expect(c.right, lessThanOrEqualTo(panel.right));
+      expect(panel.right - c.right, lessThan(24),
+          reason: 'trailing edge of the panel');
+      expect((c.center.dy - value.center.dy).abs(), lessThan(1.5),
+          reason: 'centred on the value line');
+      expect(c.left, greaterThanOrEqualTo(value.right - 0.01),
+          reason: 'the chevron never sits on the value');
+      expect(_spoken(t).where((s) => s.toLowerCase().contains('chevron')),
+          isEmpty);
+      h.dispose();
+    });
+
+    testWidgets('the chevron fits on metric detail at text scale 1.3 without '
+        'overflow or a height change', (t) async {
+      await _openRhr(t, scale: 1.3);
+      final panel = find.byKey(_panelKey);
+      expect(chevron, findsOneWidget);
+      final size = t.getSize(panel);
+      expect(t.takeException(), isNull);
+      await _scrubBack(t, _gapBack);
+      expect(t.takeException(), isNull);
+      expect(chevron, findsNothing);
+      expect(t.getSize(panel), size);
+    });
+
+    // The metric-detail screen has its own overflow at 3.1x (the range chips),
+    // so the large-text case runs on the panel alone, narrow and wide.
+    for (final w in [320.0, 390.0]) {
+      testWidgets('the panel alone at text scale 3.1, width $w: the chevron '
+          'fits and opening or not leaves the size alone', (t) async {
+        _phone(t, w, 1800);
+        Widget panel({required bool open}) => _scaled(
+            3.1,
+            Scaffold(
+                body: Padding(
+              padding: const EdgeInsets.all(16),
+              child: Align(
+                alignment: Alignment.topCenter,
+                child: ChartPanel(
+                  time: 'Wednesday, 28 September',
+                  timeSpan: const ['Today', 'Wednesday, 28 September'],
+                  scrubbed: true,
+                  color: Colors.red,
+                  cells: [
+                    ChartPanelCell('Resting heart rate',
+                        color: Colors.red, value: open ? '52 bpm' : null),
+                  ],
+                  stats: const [
+                    ChartPanelCell('7-day avg', value: '54 bpm'),
+                    ChartPanelCell('vs avg', value: '−2 bpm'),
+                  ],
+                  onOpen: open ? () {} : null,
+                  openLabel: 'Open Wednesday',
+                ),
+              ),
+            )));
+        await t.pumpWidget(panel(open: true));
+        expect(t.takeException(), isNull);
+        expect(chevron, findsOneWidget);
+        final size = t.getSize(find.byKey(_panelKey));
+        final cap = t.getRect(find.byKey(_captionKey));
+        await t.pumpWidget(panel(open: false));
+        expect(t.takeException(), isNull);
+        expect(chevron, findsNothing);
+        expect(t.getSize(find.byKey(_panelKey)), size);
+        expect(t.getRect(find.byKey(_captionKey)), cap);
+      });
+    }
+  });
+
+  // ═══════════════ sleep: the hypnogram and the night's signals ═══════════════
+  group('sleep panels', () {
+    final onset = DateTime(2026, 5, 19, 23).millisecondsSinceEpoch ~/ 1000;
+    final wake = DateTime(2026, 5, 20, 7).millisecondsSinceEpoch ~/ 1000;
+
+    SleepData data({bool signals = true}) => SleepData(
+          day: '2026-05-20',
+          night: {
+            'duration_min': 360,
+            'in_bed_min': 480,
+            'awake_min': 15,
+            'efficiency': .75,
+            'onset_ts': onset,
+            'wake_ts': wake,
+            'light_min': 120,
+            'deep_min': 120,
+            'rem_min': 105,
+            'hypnogram': [
+              {'t': onset, 'stage': 'light'},
+              {'t': onset + 3600, 'stage': 'deep'},
+              {'t': onset + 10800, 'stage': 'unobserved'},
+              {'t': onset + 18000, 'stage': 'rem'},
+              // The display samples miss this: two minutes before wake.
+              {'t': wake - 60, 'stage': 'awake'},
+              {'t': wake, 'stage': 'awake'},
+            ],
+          },
+          timeline: signals
+              ? {
+                  'hr': [
+                    {'t': onset, 'v': 50},
+                    {'t': onset + 7200, 'v': 54},
+                    {'t': onset + 14400, 'v': 58},
+                    {'t': wake, 'v': 66},
+                  ],
+                  'hrv': [
+                    {'t': onset + 7200, 'v': 42}
+                  ],
+                  'resp': [
+                    {'t': onset + 14400, 'v': 17.5}
+                  ],
+                }
+              : {},
+        );
+
+    Future<void> pump(WidgetTester t,
+        {double scale = 1,
+        bool signals = true,
+        Brightness b = Brightness.light}) async {
+      _phone(t, 390, 6200 * scale);
+      await t.pumpWidget(_scaled(
+          scale, SleepDetail(data: data(signals: signals)),
+          b: b));
+      await t.pumpAndSettle();
+      expect(t.takeException(), isNull);
+    }
+
+    Finder plot(String label) =>
+        find.byWidgetPredicate((w) => w is Scrubber && w.label == label);
+    Finder inPanel(Finder panel, String text) =>
+        find.descendant(of: panel, matching: find.text(text));
+
+    Future<void> scrub(WidgetTester t, String label, double at) async {
+      final rect = t.getRect(plot(label));
+      await t.tapAt(Offset(rect.left + rect.width * at, rect.center.dy));
+      await t.pumpAndSettle();
+      expect(t.takeException(), isNull);
+    }
+
+    for (final scale in [1.0, 1.3, 3.1]) {
+      testWidgets('both night panels are there at rest (LATEST at wake) and '
+          'keep their size and place at ${scale}x text', (t) async {
+        await pump(t, scale: scale);
+        final panels = find.byKey(_panelKey);
+        expect(panels, findsNWidgets(2),
+            reason: 'one under the hypnogram, one under the night signals');
+        final rects = [for (var i = 0; i < 2; i++) t.getRect(panels.at(i))];
+        for (var i = 0; i < 2; i++) {
+          expect(inPanel(panels.at(i), 'LATEST · 07:00'), findsOneWidget);
+          expect(inPanel(panels.at(i), 'Awake'), findsOneWidget);
+          expect(inPanel(panels.at(i), '66 bpm'), findsOneWidget);
+          expect(find.descendant(of: panels.at(i), matching: find.text('—')),
+              findsAtLeastNWidgets(2),
+              reason: 'HRV and breathing were not recorded at wake: a dash, '
+                  'never a neighbour\'s reading');
+          final box = t.widget<Container>(panels.at(i)).decoration as BoxDecoration;
+          expect(box.border, isNull, reason: 'no border at rest');
+        }
+        final surfaces = find.byType(Surface).evaluate().length;
+        for (final (label, at, time) in [
+          ('Hypnogram', .25, '01:00'),
+          ('Through the night', .5, '03:00'),
+          ('Hypnogram', .75, '05:00'),
+        ]) {
+          await scrub(t, label, at);
+          expect(panels, findsNWidgets(2));
+          expect(find.byType(Surface).evaluate().length, surfaces,
+              reason: 'the old readout added a Surface on every scrub');
+          for (var i = 0; i < 2; i++) {
+            expect(inPanel(panels.at(i), 'SELECTED · $time'), findsOneWidget);
+            expect(t.getRect(panels.at(i)), rects[i], reason: 'no shift at $time');
+            final box =
+                t.widget<Container>(panels.at(i)).decoration as BoxDecoration;
+            expect(box.border, isNotNull);
+          }
+        }
+      });
+    }
+
+    testWidgets('SELECTED shows the stage and EVERY signal at that instant, '
+        'and a dash where one was not recorded', (t) async {
+      await pump(t);
+      final panels = find.byKey(_panelKey);
+      expect(panels, findsNWidgets(2), reason: 'no panels under the charts');
+      // 01:00: deep sleep; heart rate and HRV were both recorded here.
+      await scrub(t, 'Hypnogram', .25);
+      for (var i = 0; i < 2; i++) {
+        expect(inPanel(panels.at(i), 'Deep sleep'), findsOneWidget);
+        expect(inPanel(panels.at(i), '54 bpm'), findsOneWidget);
+        expect(inPanel(panels.at(i), '42 ms'), findsOneWidget);
+      }
+      // 03:00: an unobserved stretch; heart rate and breathing, no HRV.
+      await scrub(t, 'Through the night', .5);
+      for (var i = 0; i < 2; i++) {
+        expect(inPanel(panels.at(i), 'Not measured'), findsOneWidget,
+            reason: 'a hole in the record is not a stage');
+        expect(inPanel(panels.at(i), '58 bpm'), findsOneWidget);
+        expect(find.descendant(of: panels.at(i), matching: find.textContaining('17.5')),
+            findsOneWidget);
+        expect(find.descendant(of: panels.at(i), matching: find.textContaining(' ms')),
+            findsNothing,
+            reason: 'no HRV was recorded near 03:00');
+      }
+      // 05:00: REM, but no signal within reach: nothing is invented.
+      await scrub(t, 'Hypnogram', .75);
+      for (var i = 0; i < 2; i++) {
+        expect(inPanel(panels.at(i), 'REM'), findsOneWidget);
+        for (final unit in [' bpm', ' ms', 'br/min']) {
+          expect(find.descendant(of: panels.at(i), matching: find.textContaining(unit)),
+              findsNothing,
+              reason: 'no signal near 05:00, so no $unit value');
+        }
+      }
+    });
+
+    testWidgets('the stage comes from the timestamped boundaries, even '
+        'between display samples; the slider agrees', (t) async {
+      await pump(t);
+      final panels = find.byKey(_panelKey);
+      expect(panels, findsNWidgets(2), reason: 'no panels under the charts');
+      for (final (seconds, time, stage) in [
+        (3599, '23:59', 'Light sleep'),
+        (3600, '00:00', 'Deep sleep'),
+        (10799, '01:59', 'Deep sleep'),
+        (10800, '02:00', 'Not measured'),
+        (17999, '03:59', 'Not measured'),
+        (18000, '04:00', 'REM'),
+        (28739, '06:58', 'REM'),
+        (28740, '06:59', 'Awake'),
+      ]) {
+        await scrub(t, 'Hypnogram', seconds / 28800);
+        for (var i = 0; i < 2; i++) {
+          expect(inPanel(panels.at(i), 'SELECTED · $time'), findsOneWidget,
+              reason: 'panel $i at $seconds s');
+          expect(inPanel(panels.at(i), stage), findsOneWidget,
+              reason: 'panel $i at $seconds s');
+        }
+        final s = t.widget<Scrubber>(plot('Hypnogram'));
+        final spoken = stage == 'Not measured' ? 'not measured' : stage;
+        // The slider speaks the whole reading the panel is showing: the stage
+        // and every signal at that second, a missing one as 'No record'.
+        final hr = seconds >= 28000 ? '66 bpm' : 'No record';
+        expect(s.describe(seconds / 28800),
+            '$time, $spoken, Heart rate $hr, HRV No record, Breathing No record');
+      }
+    });
+
+    for (final b in Brightness.values) {
+      testWidgets('the stage caption and value clear 4.5:1 on the panel in $b',
+          (t) async {
+        await pump(t, b: b);
+        expect(find.byKey(_panelKey), findsNWidgets(2));
+        final panel = find.byKey(_panelKey).first;
+        final p = P.of(t.element(panel));
+        for (final (at, stage, pigment) in [
+          (0.0, 'Light sleep', C.sky),
+          (.25, 'Deep sleep', C.blue),
+          (.75, 'REM', C.teal),
+          (1.0, 'Awake', C.orange),
+        ]) {
+          await scrub(t, 'Hypnogram', at == 1 ? .9999 : at);
+          final caption = find.descendant(
+              of: panel, matching: find.byKey(_captionKey));
+          for (final text in [inPanel(panel, stage), caption]) {
+            final color = t.widget<Text>(text).style!.color!;
+            expect(color, p.on(pigment));
+            expect(P.contrast(color, p.card2), greaterThanOrEqualTo(4.5));
+          }
+        }
+      });
+    }
+
+    testWidgets('a night with no recorded signals keeps one panel for the '
+        'hypnogram and fabricates no values', (t) async {
+      await pump(t, signals: false);
+      final panels = find.byKey(_panelKey);
+      expect(panels, findsOneWidget);
+      expect(inPanel(panels, 'LATEST · 07:00'), findsOneWidget);
+      expect(inPanel(panels, 'Awake'), findsOneWidget);
+      for (final unit in [' bpm', ' ms', 'br/min']) {
+        expect(find.descendant(of: panels, matching: find.textContaining(unit)),
+            findsNothing);
+      }
+    });
+
+    /// Labels and values a screen reader reads as the node itself (not the
+    /// neighbouring-step values a slider also carries).
+    List<String> said(WidgetTester t) {
+      final out = <String>[];
+      void walk(SemanticsNode n) {
+        final d = n.getSemanticsData();
+        for (final x in [d.label, d.value]) {
+          if (x.isNotEmpty) out.add(x);
+        }
+        n.visitChildren((c) {
+          walk(c);
+          return true;
+        });
+      }
+
+      walk(t.binding.renderViews.first.owner!.semanticsOwner!.rootSemanticsNode!);
+      return out;
+    }
+
+    int times(WidgetTester t, String what) => said(t)
+        .map((s) => what.allMatches(s).length)
+        .fold(0, (a, b) => a + b);
+
+    // Two charts, two panels, each showing the same instant: each chart's
+    // reading is spoken by exactly one owner, so every displayed value is
+    // spoken twice on the page and never twice for one chart.
+    testWidgets('at rest the panel speaks LATEST once per chart: the stage '
+        'and every signal, a missing one as No record', (t) async {
+      final h = t.ensureSemantics();
+      await pump(t);
+      final readings = find.semantics.byLabel(RegExp(r'^LATEST'));
+      expect(readings.evaluate(), hasLength(2), reason: 'one per panel');
+      for (final n in readings.evaluate()) {
+        expect(n.label,
+            'LATEST · 07:00, Stage Awake, Heart rate 66 bpm, '
+            'HRV No record, Breathing No record');
+      }
+      for (final value in ['Stage Awake', '66 bpm', 'HRV No record', 'Breathing No record']) {
+        expect(times(t, value), 2, reason: '$value: once per panel');
+      }
+      h.dispose();
+    });
+
+    testWidgets('selected, the slider speaks the whole reading once per chart '
+        'and the panel is silent', (t) async {
+      final h = t.ensureSemantics();
+      await pump(t);
+      await scrub(t, 'Hypnogram', .25);
+      const full = '01:00, Deep sleep, Heart rate 54 bpm, HRV 42 ms, '
+          'Breathing No record';
+      for (final label in ['Hypnogram', 'Through the night']) {
+        final node = find.semantics.byLabel(label).evaluate().single;
+        expect(node.value, full, reason: '$label slider');
+      }
+      for (final value in ['Deep sleep', '54 bpm', '42 ms', 'Breathing No record']) {
+        expect(times(t, value), 2, reason: '$value: once per slider');
+      }
+      expect(find.bySemanticsLabel(RegExp(r'^(LATEST|SELECTED)', caseSensitive: false)),
+          findsNothing,
+          reason: 'the panel caption and cells are not a second announcement');
+      // Letting go is not possible here (a tap selects), but a second
+      // selection moves the one reading rather than adding another.
+      await scrub(t, 'Through the night', .5);
+      expect(find.semantics.byLabel('Hypnogram').evaluate().single.value,
+          '03:00, not measured, Heart rate 58 bpm, HRV No record, '
+          'Breathing 17.5 br/min');
+      h.dispose();
+    });
+  });
+}
diff --git a/test/graphs_scrub_workout_test.dart b/test/graphs_scrub_workout_test.dart
new file mode 100644
index 000000000..ea5ad9bdb
--- /dev/null
+++ b/test/graphs_scrub_workout_test.dart
@@ -0,0 +1,113 @@
+// SCRUB + PANEL ON THE WORKOUT "HEART EFFORT BY DAY" CHART (Graphs PR phase 5,
+// red tests).
+//
+// The For-you tab's Training load section draws seven day bars of heart effort
+// (TRIMP). Upstream cannot read a bar; the fork's chart scrubbed (ChartScrub,
+// bars). The panel reads LATEST on today, SELECTED on the touched bar, and a
+// dash on a day that derived nothing, in the same inset box as every chart.
+//
+// The "Mechanical load" (tonnage) card above/below it takes the identical
+// change but needs strength-set rows from the real database (LocalDb), which a
+// widget test cannot seed without sqflite; it is covered at green by the same
+// helper and listed as untested-by-fixture in phase5.report.md.
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/data/local_repository.dart';
+import 'package:openstrap_edge/state/app_state.dart';
+import 'package:openstrap_edge/state/locale_controller.dart';
+import 'package:openstrap_edge/ui2/screens/screens.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+import 'package:provider/provider.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import 'support/scrub_surface_laws.dart';
+
+/// Heart effort of 20 + 10 * (6 - back) points: today 80 ... 6 days ago 20,
+/// with no figure 3 days ago.
+const _gapBack = 3, _scrubbedBack = 5;
+
+class _Repo extends LocalRepository {
+  @override
+  Future<Map<String, dynamic>> getProfile() async => {};
+
+  @override
+  Future<Map<String, dynamic>> getInsights() async => {
+        // No `tsb`: the load card's header Row (existing code, not this
+        // change) overflows by 15 px at 1.3x text with the Form pill. Reported
+        // in phase5.report.md.
+        'load': {
+          'value': {'ctl': 34.0, 'atl': 40.0}
+        }
+      };
+
+  @override
+  Future<Map<String, dynamic>> getChart(String metric,
+      {int? from,
+      int? to,
+      Set<String> signals = const {},
+      Set<String> extra = const {}}) async {
+    final n = DateTime.now();
+    return {
+      'points': [
+        for (var back = 6; back >= 0; back--)
+          if (back != _gapBack)
+            {
+              't': DateTime(n.year, n.month, n.day - back, 12)
+                      .millisecondsSinceEpoch ~/
+                  1000,
+              'v': 20.0 + 10 * (6 - back),
+            },
+      ],
+    };
+  }
+
+  @override
+  Future<Map<String, dynamic>> getWorkouts({String range = 'month'}) async =>
+      {'workouts': const []};
+
+  @override
+  Future<Map<String, dynamic>> getRecords() async => {};
+}
+
+Future<void> _mount(WidgetTester t, double scale) async {
+  SharedPreferences.setMockInitialValues({});
+  phone(t, 390, 700);
+  final app = AppState.forTesting();
+  addTearDown(app.dispose);
+  app.repo = _Repo();
+  await t.pumpWidget(scaledApp(
+      scale,
+      MultiProvider(
+        providers: [
+          ChangeNotifierProvider<AppState>.value(value: app),
+          ChangeNotifierProvider<LocaleController>.value(
+              value: LocaleController.seed(null)),
+        ],
+        child: const Scaffold(body: WorkoutScreen()),
+      )));
+  await t.pumpAndSettle();
+  // The page is a lazy list: bring the chart's card in range first.
+  for (var i = 0;
+      i < 20 && find.text('Heart effort by day').evaluate().isEmpty;
+      i++) {
+    await t.drag(find.byType(Scrollable).first, const Offset(0, -300));
+    await t.pumpAndSettle();
+  }
+  // Controls: the load section and its one chart are on screen.
+  expect(find.text('Heart effort by day'), findsWidgets);
+  expect(find.byType(ChartFrame), findsOneWidget);
+}
+
+void main() {
+  defineSurfaceLaws(SurfaceRig(
+    name: 'workout heart effort',
+    mount: _mount,
+    plot: () => find.descendant(
+        of: find.byType(ChartFrame), matching: find.byType(Scrubber)),
+    slots: 7,
+    bars: true,
+    scrubbed: 6 - _scrubbedBack,
+    gap: 6 - _gapBack,
+    valueAt: (slot) => '^${20 + 10 * slot}points',
+  ));
+}
diff --git a/test/graphs_slot_scrub_anchor_test.dart b/test/graphs_slot_scrub_anchor_test.dart
new file mode 100644
index 000000000..b72658608
--- /dev/null
+++ b/test/graphs_slot_scrub_anchor_test.dart
@@ -0,0 +1,89 @@
+// SlotScrub dates its slots from the calendar day its caller built the series
+// for, not from the clock at each touch. A chart left open across midnight
+// must keep labelling its data with the days the data is from.
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/ui2/screens/slot_scrub.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+import 'support/scrub_surface_laws.dart';
+
+Widget _chart(DateTime anchor,
+        {List<double?> series = const [10, 20, 30],
+        String? Function(int)? dayWord}) =>
+    scaledApp(
+      1,
+      Scaffold(
+        body: SlotScrub(
+          series: series,
+          dayWord: dayWord,
+          anchor: anchor,
+          bars: true,
+          label: 'Load',
+          color: Colors.purple,
+          format: (v) => '${v.round()} points',
+          builder: (c, pick, scrub, panel) => Column(children: [
+            SizedBox(
+                height: 80,
+                child: scrub(const SizedBox.expand(key: ValueKey('plot')))),
+            panel,
+          ]),
+        ),
+      ),
+    );
+
+String _caption(WidgetTester t) =>
+    plainOf(t.widget<Text>(find.byKey(captionKey)));
+
+void main() {
+  testWidgets('an anchor of yesterday labels the last slot as yesterday, at '
+      'rest and when touched', (t) async {
+    final n = DateTime.now();
+    final yesterday = DateTime(n.year, n.month, n.day - 1);
+    await t.pumpWidget(_chart(yesterday));
+    await t.pumpAndSettle();
+    expect(_caption(t), startsWith('LATEST · '));
+    expect(_caption(t), isNot(contains('Today')),
+        reason: 'the clock says today; the series says yesterday');
+    expect(namesDay(_caption(t), 1), isTrue, reason: _caption(t));
+
+    final box = t.getRect(find.byType(Scrubber));
+    // The last of three bars, then the first.
+    await t.tapAt(Offset(box.left + box.width * 5 / 6, box.center.dy));
+    await t.pumpAndSettle();
+    expect(_caption(t), startsWith('SELECTED · '));
+    expect(namesDay(_caption(t), 1), isTrue, reason: _caption(t));
+    await t.tapAt(Offset(box.left + box.width * 1 / 6, box.center.dy));
+    await t.pumpAndSettle();
+    expect(namesDay(_caption(t), 3), isTrue,
+        reason: 'the first slot is two days before the anchor: "${_caption(t)}"');
+  });
+
+  testWidgets('an anchor of today still labels the last slot Today',
+      (t) async {
+    final n = DateTime.now();
+    await t.pumpWidget(_chart(DateTime(n.year, n.month, n.day)));
+    await t.pumpAndSettle();
+    expect(_caption(t), 'LATEST · Today');
+  });
+
+  testWidgets('no slot has a value: the caption names no day', (t) async {
+    final n = DateTime.now();
+    await t.pumpWidget(_chart(DateTime(n.year, n.month, n.day),
+        series: const [null, null, null]));
+    await t.pumpAndSettle();
+    expect(_caption(t), isNot(contains(RegExp('Today|Yesterday|[0-9]'))),
+        reason: 'LATEST must not name a day with no reading: "${_caption(t)}"');
+  });
+
+  testWidgets('a day word replaces the day name in the panel and the slider',
+      (t) async {
+    final n = DateTime.now();
+    await t.pumpWidget(_chart(DateTime(n.year, n.month, n.day),
+        dayWord: (i) => i == 2 ? 'Last night' : null));
+    await t.pumpAndSettle();
+    expect(_caption(t), 'LATEST · Last night');
+    expect(t.widget<Scrubber>(find.byType(Scrubber)).describe(0.95),
+        'Last night, 30 points');
+  });
+}
diff --git a/test/russian_review_findings_test.dart b/test/russian_review_findings_test.dart
index 9bfbee005..717c56566 100644
--- a/test/russian_review_findings_test.dart
+++ b/test/russian_review_findings_test.dart
@@ -509,6 +509,10 @@ void main() {
                   ? ru.metricDetailRankFromBand(axisDay(ts), 12, band)
                   : ru.metricDetailRankFrom(axisDay(ts), 12));
         expect(expected, contains('выше, чем в 12% ваших дней'));
+        // The scrub panel under the chart is always on screen now, which moves
+        // this line below the 600 px test viewport; bring it into view.
+        await t.ensureVisible(find.text(expected, skipOffstage: false));
+        await t.pumpAndSettle();
         expect(find.text(expected), findsOneWidget);
         expect(t.takeException(), isNull);
       });
diff --git a/test/start_card_in_list_test.dart b/test/start_card_in_list_test.dart
new file mode 100644
index 000000000..372292296
--- /dev/null
+++ b/test/start_card_in_list_test.dart
@@ -0,0 +1,45 @@
+// The start card inside a scrolling page: its Spacer needs a bounded height,
+// which a ListView does not give. It asserted in debug and had no size.
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/ui2/screens/start_card.dart';
+import 'package:openstrap_edge/ui2/theme.dart';
+
+void main() {
+  for (final scale in [1.0, 1.3]) {
+    testWidgets('lays out inside a ListView at text scale $scale', (t) async {
+      t.view.physicalSize = const Size(390 * 3, 800 * 3);
+      t.view.devicePixelRatio = 3;
+      addTearDown(t.view.reset);
+      await t.pumpWidget(MaterialApp(
+        theme: buildTheme(Brightness.light),
+        builder: (c, child) => MediaQuery(
+          data: MediaQuery.of(c)
+              .copyWith(textScaler: TextScaler.linear(scale)),
+          child: child!,
+        ),
+        home: Scaffold(
+          body: ListView(children: const [
+            StartCard(
+              label: 'START A SESSION',
+              count: 71,
+              noun: 'activities',
+              asset: 'mascot_workout.png',
+              accent: C.purple,
+              deep: C.indigo,
+            ),
+          ]),
+        ),
+      ));
+      expect(t.takeException(), isNull);
+      final card = t.getRect(find.byType(StartCard));
+      expect(card.height, greaterThanOrEqualTo(190));
+      final label = t.getRect(find.text('START A SESSION'));
+      // The only Icon in the card is the play button.
+      final play = t.getRect(find.byType(Icon));
+      expect(label.bottom, lessThan(play.top),
+          reason: 'the label sits above the play button');
+      expect(play.bottom, lessThanOrEqualTo(card.bottom));
+    });
+  }
+}
diff --git a/test/support/process_tz.dart b/test/support/process_tz.dart
new file mode 100644
index 000000000..f0ba165fa
--- /dev/null
+++ b/test/support/process_tz.dart
@@ -0,0 +1,33 @@
+// Moves the PROCESS timezone with libc setenv("TZ") + tzset(), the way
+// test/day_window_dst_test.dart does. Dart's DateTime reads the C library's
+// local time on every call, so this genuinely re-homes the local calendar. The
+// host is very unlikely to sit in a DST zone, and CI runs under UTC, where a
+// UTC-placed or fixed-24-hour day would pass every ordinary date. POSIX only.
+import 'dart:ffi';
+
+import 'package:ffi/ffi.dart';
+
+typedef _SetenvNative = Int32 Function(Pointer<Utf8>, Pointer<Utf8>, Int32);
+typedef _SetenvDart = int Function(Pointer<Utf8>, Pointer<Utf8>, int);
+typedef _UnsetenvNative = Int32 Function(Pointer<Utf8>);
+typedef _UnsetenvDart = int Function(Pointer<Utf8>);
+typedef _TzsetNative = Void Function();
+typedef _TzsetDart = void Function();
+
+/// Sets the process timezone to [tz] (an IANA name), or clears it when null.
+void setProcessTz(String? tz) {
+  final lib = DynamicLibrary.process();
+  final key = 'TZ'.toNativeUtf8();
+  try {
+    if (tz == null) {
+      lib.lookupFunction<_UnsetenvNative, _UnsetenvDart>('unsetenv')(key);
+    } else {
+      final value = tz.toNativeUtf8();
+      lib.lookupFunction<_SetenvNative, _SetenvDart>('setenv')(key, value, 1);
+      calloc.free(value);
+    }
+    lib.lookupFunction<_TzsetNative, _TzsetDart>('tzset')();
+  } finally {
+    calloc.free(key);
+  }
+}
diff --git a/test/support/scrub_surface_laws.dart b/test/support/scrub_surface_laws.dart
new file mode 100644
index 000000000..bb70639a9
--- /dev/null
+++ b/test/support/scrub_surface_laws.dart
@@ -0,0 +1,314 @@
+// THE SCRUB + PANEL CONTRACT, AS LAWS A SURFACE CAN BE HELD TO (Graphs PR,
+// phase 5). One rig per screen; the same laws for every rig, so Health, Workout
+// and the month grid cannot drift apart. The contract is the one phases 2-3
+// pinned on metric detail and sleep (graphs_scrub_panel_test.dart,
+// graphs_scroll_first_scrub_test.dart):
+//   * a `chart-panel` is present at rest, LATEST, on the newest reading;
+//   * a tap or a horizontal-dominant drag selects: SELECTED, that day's value;
+//   * a day with no reading reads a dash, never a neighbour;
+//   * the panel keeps its rect across rest / selected / gap;
+//   * the slider speaks the selection ONCE; the caption is not announced;
+//   * a vertical drag that starts on the chart scrolls the page and selects
+//     nothing; a horizontal-dominant drag scrubs and the page stays;
+//   * no "Open <day>" button where there is no day screen to open.
+//
+// FIXTURES are dated backwards from the wall clock in LOCAL calendar days
+// (never a fixed date, never UTC), so they hold in any host timezone.
+import 'package:flutter/material.dart';
+import 'package:flutter/semantics.dart' show SemanticsNode;
+import 'package:flutter_test/flutter_test.dart';
+import 'package:openstrap_edge/l10n/app_localizations.dart';
+import 'package:openstrap_edge/state/clock_format.dart';
+import 'package:openstrap_edge/ui2/ui2.dart';
+
+const panelKey = ValueKey('chart-panel');
+const captionKey = ValueKey('chart-panel-caption');
+const valueKey = ValueKey('chart-panel-value');
+
+String plainOf(Text x) => x.data ?? x.textSpan?.toPlainText() ?? '';
+
+Widget scaledApp(double scale, Widget home) => MaterialApp(
+      locale: const Locale('en'),
+      localizationsDelegates: AppLocalizations.localizationsDelegates,
+      supportedLocales: AppLocalizations.supportedLocales,
+      theme: buildTheme(Brightness.light),
+      builder: (c, child) => MediaQuery(
+        data: MediaQuery.of(c).copyWith(textScaler: TextScaler.linear(scale)),
+        child: child!,
+      ),
+      home: home,
+    );
+
+void phone(WidgetTester t, double w, double h) {
+  t.view.physicalSize = Size(w * 3, h * 3);
+  t.view.devicePixelRatio = 3;
+  addTearDown(t.view.reset);
+}
+
+/// Every string a screen reader could be given, from the whole tree.
+List<String> spoken(WidgetTester t) {
+  final out = <String>[];
+  void walk(SemanticsNode n) {
+    final d = n.getSemanticsData();
+    for (final s in [d.label, d.value, d.increasedValue, d.decreasedValue]) {
+      if (s.isNotEmpty) out.add(s);
+    }
+    n.visitChildren((c) {
+      walk(c);
+      return true;
+    });
+  }
+
+  walk(t.binding.renderViews.first.owner!.semanticsOwner!.rootSemanticsNode!);
+  return out;
+}
+
+/// Whether [caption] names [back] days ago, as the chart words it: 'today',
+/// 'yesterday', or the weekday and the day of the month.
+bool namesDay(String caption, int back, {String? lastWord}) {
+  final c = caption.toLowerCase();
+  if (back == 0 && lastWord != null && c.contains(lastWord.toLowerCase())) {
+    return true;
+  }
+  final n = DateTime.now();
+  final d = DateTime(n.year, n.month, n.day - back);
+  const wd = ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'];
+  if (back == 0 && c.contains('today')) return true;
+  if (back == 1 && c.contains('yesterday')) return true;
+  return c.contains(wd[d.weekday - 1]) && RegExp('\\b${d.day}\\b').hasMatch(c);
+}
+
+/// One screen's chart, described for the laws. Slot 0 is the OLDEST; the last
+/// slot is today.
+class SurfaceRig {
+  const SurfaceRig({
+    required this.name,
+    required this.mount,
+    required this.plot,
+    required this.slots,
+    required this.bars,
+    required this.scrubbed,
+    required this.gap,
+    required this.valueAt,
+    this.lastWord,
+  });
+
+  final String name;
+
+  /// Pumps the screen at [scale] text scale with the fixture and brings the
+  /// chart's page into view. Must assert its own controls (the chart's frame is
+  /// on screen) so a failure afterwards is about the contract.
+  final Future<void> Function(WidgetTester t, double scale) mount;
+
+  /// The chart's `Scrubber`.
+  final Finder Function() plot;
+
+  /// How many slots the chart has, and whether they are bars (a slot is an
+  /// interval, so its centre is `(i + .5) / n`) or points on a line (`i / (n -
+  /// 1)`).
+  final int slots;
+  final bool bars;
+
+  /// A slot with a reading that is not the newest, and a slot with none.
+  final int scrubbed, gap;
+
+  /// The panel's value for [slot] with all whitespace removed, as a pattern.
+  /// Slot `slots - 1` is the one the panel shows at rest.
+  final String Function(int slot) valueAt;
+
+  /// A chart that words its newest slot its own way (HRV: "Last night").
+  final String? lastWord;
+
+  int dayBack(int slot) => slots - 1 - slot;
+
+  double fraction(int slot) =>
+      bars ? (slot + .5) / slots : slot / (slots - 1);
+}
+
+Finder get _vertical => find.byWidgetPredicate(
+    (w) => w is Scrollable && w.axis == Axis.vertical);
+
+String _caption(WidgetTester t) {
+  final f = find.descendant(
+      of: find.byKey(panelKey), matching: find.byKey(captionKey));
+  expect(f, findsOneWidget, reason: 'the panel has no caption');
+  return plainOf(t.widget<Text>(f));
+}
+
+String _value(WidgetTester t) {
+  final f = find.descendant(
+      of: find.byKey(panelKey), matching: find.byKey(valueKey));
+  expect(f, findsOneWidget, reason: 'the panel has no value');
+  return [
+    for (final x in t.widgetList<Text>(
+        find.descendant(of: f, matching: find.byType(Text))))
+      plainOf(x)
+  ].join().replaceAll(RegExp(r'\s+'), '');
+}
+
+/// The chart on screen and the panel under it. The first assertions say what is
+/// missing, so a red run names the surface and not a cascade.
+Future<void> _ready(WidgetTester t, SurfaceRig r, double scale) async {
+  await r.mount(t, scale);
+  expect(r.plot(), findsOneWidget,
+      reason: '${r.name}: the chart has no scroll-first Scrubber');
+  expect(find.byKey(panelKey), findsOneWidget,
+      reason: '${r.name}: no chart-panel under the chart at rest');
+  expect(t.takeException(), isNull, reason: '${r.name} lays out at $scale');
+}
+
+Future<void> _tapSlot(WidgetTester t, SurfaceRig r, int slot) async {
+  await t.ensureVisible(r.plot());
+  await t.pumpAndSettle();
+  final box = t.getRect(r.plot());
+  await t.tapAt(
+      Offset(box.left + box.width * r.fraction(slot), box.center.dy));
+  await t.pumpAndSettle();
+}
+
+void defineSurfaceLaws(SurfaceRig r) {
+  group('${r.name}: scrub and panel', () {
+    setUp(() => ClockFormatController.seed(ClockFormat.h24));
+    tearDown(ClockFormatController.debugReset);
+
+    for (final scale in [1.0, 1.3]) {
+      testWidgets('at rest the panel is there: LATEST, today, the newest '
+          'reading (x$scale)', (t) async {
+        await _ready(t, r, scale);
+        final cap = _caption(t);
+        expect(cap.toLowerCase(), startsWith('latest'));
+        expect(namesDay(cap, 0, lastWord: r.lastWord), isTrue, reason: 'caption "$cap" names no day');
+        expect(_value(t), matches(r.valueAt(r.slots - 1)));
+        expect(t.widget<Scrubber>(r.plot()).value, isNull,
+            reason: 'nothing is selected before a touch');
+      });
+
+      testWidgets('a tap selects: SELECTED, that day, its value; the panel '
+          'keeps its rect (x$scale)', (t) async {
+        await _ready(t, r, scale);
+        await t.ensureVisible(r.plot());
+        await t.pumpAndSettle();
+        final rect = t.getRect(find.byKey(panelKey));
+        await _tapSlot(t, r, r.scrubbed);
+        expect(find.byKey(panelKey), findsOneWidget);
+        final cap = _caption(t);
+        expect(cap.toLowerCase(), startsWith('selected'));
+        expect(namesDay(cap, r.dayBack(r.scrubbed)), isTrue,
+            reason: 'caption "$cap" is not ${r.dayBack(r.scrubbed)} days back');
+        expect(_value(t), matches(r.valueAt(r.scrubbed)));
+        expect(t.getRect(find.byKey(panelKey)), rect,
+            reason: 'a scrub moves nothing');
+        expect(t.takeException(), isNull);
+      });
+
+      testWidgets('a day with no reading is a dash, and the panel still '
+          'does not move (x$scale)', (t) async {
+        await _ready(t, r, scale);
+        await t.ensureVisible(r.plot());
+        await t.pumpAndSettle();
+        final rect = t.getRect(find.byKey(panelKey));
+        await _tapSlot(t, r, r.gap);
+        final cap = _caption(t);
+        expect(cap.toLowerCase(), startsWith('selected'));
+        expect(namesDay(cap, r.dayBack(r.gap)), isTrue);
+        expect(_value(t), startsWith('—'),
+            reason: 'never a neighbour, never an interpolation');
+        expect(t.getRect(find.byKey(panelKey)), rect);
+        expect(t.takeException(), isNull);
+      });
+    }
+
+    testWidgets('a vertical drag that starts on the chart scrolls the page '
+        'and selects nothing', (t) async {
+      await _ready(t, r, 1);
+      await t.ensureVisible(r.plot());
+      await t.pumpAndSettle();
+      final scroll = t
+          .state<ScrollableState>(
+              find.ancestor(of: r.plot(), matching: _vertical).first)
+          .position;
+      expect(scroll.maxScrollExtent, greaterThan(100),
+          reason: 'a real scrollable page');
+      final before = scroll.pixels;
+      final dy = scroll.extentAfter > 150 ? -130.0 : 130.0;
+      await t.timedDrag(
+          r.plot(), Offset(12, dy), const Duration(milliseconds: 350));
+      await t.pumpAndSettle();
+      expect((scroll.pixels - before).abs(), greaterThan(40),
+          reason: 'the page moved under the thumb');
+      await t.ensureVisible(r.plot());
+      await t.pumpAndSettle();
+      expect(t.widget<Scrubber>(r.plot()).value, isNull);
+      expect(_caption(t).toLowerCase(), startsWith('latest'),
+          reason: 'a page scroll is not a selection');
+      expect(t.takeException(), isNull);
+    });
+
+    testWidgets('a horizontal-dominant drag scrubs and the page stays put',
+        (t) async {
+      await _ready(t, r, 1);
+      await t.ensureVisible(r.plot());
+      await t.pumpAndSettle();
+      final scroll = t
+          .state<ScrollableState>(
+              find.ancestor(of: r.plot(), matching: _vertical).first)
+          .position;
+      final before = scroll.pixels;
+      await t.drag(r.plot(), const Offset(60, 5));
+      await t.pumpAndSettle();
+      expect(scroll.pixels, closeTo(before, 1));
+      expect(t.widget<Scrubber>(r.plot()).value, isNotNull);
+      expect(_caption(t).toLowerCase(), startsWith('selected'));
+      expect(t.takeException(), isNull);
+    });
+
+    testWidgets('spoken once at rest: with nothing selected the panel speaks '
+        'the LATEST day and value, and the slider repeats neither', (t) async {
+      final h = t.ensureSemantics();
+      await _ready(t, r, 1);
+      await t.ensureVisible(r.plot());
+      await t.pumpAndSettle();
+      final latest = find.semantics.byLabel(RegExp(r'^LATEST'));
+      expect(latest.evaluate(), hasLength(1),
+          reason: '${r.name}: the resting reading has no owner (or two)');
+      final said = latest.evaluate().single.label;
+      expect(namesDay(said, 0, lastWord: r.lastWord), isTrue, reason: '"$said" names no day');
+      expect(said.replaceAll(RegExp(r'\s+'), ''),
+          contains(RegExp(r.valueAt(r.slots - 1)
+              .replaceAll(RegExp(r'^\^|\$$'), ''))),
+          reason: 'the value shown at rest is spoken');
+      expect(t.widget<Scrubber>(r.plot()).value, isNull);
+      expect(t.getSemantics(r.plot()).value, 'Nothing selected',
+          reason: 'the slider owns nothing at rest; the panel owns the reading');
+      h.dispose();
+    });
+
+    testWidgets('spoken once: the slider says the selected day and value; '
+        'the panel does not repeat it', (t) async {
+      final h = t.ensureSemantics();
+      await _ready(t, r, 1);
+      await _tapSlot(t, r, r.scrubbed);
+      final s = t.widget<Scrubber>(r.plot());
+      final said = s.describe(s.value!);
+      expect(said, isNotEmpty);
+      expect(spoken(t).where((x) => x.contains(said)), hasLength(1),
+          reason: 'the selection is voiced once across slider and panel');
+      expect(
+          find.bySemanticsLabel(
+              RegExp(r'^(LATEST|SELECTED)', caseSensitive: false)),
+          findsNothing,
+          reason: 'the visual caption is not a second announcement');
+      h.dispose();
+    });
+
+    testWidgets('offers no "Open <day>" button: there is no day screen behind '
+        'this chart', (t) async {
+      final h = t.ensureSemantics();
+      await _ready(t, r, 1);
+      await _tapSlot(t, r, r.scrubbed);
+      expect(find.bySemanticsLabel(RegExp(r'^Open ')), findsNothing,
+          reason: 'an action button is a promise of a screen');
+      h.dispose();
+    });
+  });
+}
diff --git a/test/ui2_trend_reading_test.dart b/test/ui2_trend_reading_test.dart
index cf6664252..14cc3c06c 100644
--- a/test/ui2_trend_reading_test.dart
+++ b/test/ui2_trend_reading_test.dart
@@ -4,6 +4,7 @@
 // stage chart.
 
 import 'package:flutter/material.dart';
+import 'package:flutter/semantics.dart' show SemanticsNode;
 import 'package:flutter_test/flutter_test.dart';
 import 'package:openstrap_edge/models/metric.dart';
 import 'package:openstrap_edge/ui2/screens/screens.dart';
@@ -134,7 +135,50 @@ void main() {
           (w) => w is Scrubber && w.label == 'Recovery');
       await t.tapAt(t.getBottomRight(strip) - const Offset(1, 1));
       await t.pumpAndSettle();
-      expect(find.textContaining('· 20 · Rest today'), findsOneWidget);
+      // The panel under the chart replaced the pop-in line: the touched day
+      // (the last bar is today) and its score and band.
+      final panel = find.byKey(const ValueKey('chart-panel'));
+      expect(find.descendant(of: panel, matching: find.text('SELECTED · Today')),
+          findsOneWidget);
+      expect(
+          find.descendant(of: panel, matching: find.text('20 · Rest today')),
+          findsOneWidget);
+    });
+
+    testWidgets('the reading is spoken once: by the panel at rest, by the '
+        'slider while a day is selected', (t) async {
+      final handle = t.ensureSemantics();
+      final s = <double?>[for (var i = 0; i < 20; i++) 50, 80, 20];
+      await _host(t, ReadinessDetail(data: data(s)), height: 2400, screen: true);
+      int times(String what) {
+        var n = 0;
+        void walk(SemanticsNode x) {
+          final d = x.getSemanticsData();
+          for (final y in [d.label, d.value]) {
+            n += what.allMatches(y).length;
+          }
+          x.visitChildren((c) {
+            walk(c);
+            return true;
+          });
+        }
+
+        walk(t.binding.renderViews.first.owner!.semanticsOwner!.rootSemanticsNode!);
+        return n;
+      }
+
+      final latest = find.semantics.byLabel(RegExp(r'^LATEST'));
+      expect(latest.evaluate().single.label,
+          'LATEST · Today, Recovery 20 · Rest today');
+      expect(times('20 · Rest today'), 1, reason: 'at rest: the panel only');
+      final strip = find.byWidgetPredicate(
+          (w) => w is Scrubber && w.label == 'Recovery');
+      await t.tapAt(t.getBottomRight(strip) - const Offset(1, 1));
+      await t.pumpAndSettle();
+      expect(latest, findsNothing);
+      expect(find.semantics.byLabel(RegExp(r'^SELECTED')), findsNothing);
+      expect(times('20 · Rest today'), 1, reason: 'selected: the slider only');
+      handle.dispose();
     });
 
     testWidgets('under two weeks there is no band, and one line says why',