diff --git a/.claude/skills/swift/references/gotchas.md b/.claude/skills/swift/references/gotchas.md
index bfd7a77693..572b7377fb 100644
--- a/.claude/skills/swift/references/gotchas.md
+++ b/.claude/skills/swift/references/gotchas.md
@@ -454,6 +454,13 @@ Keep measured findings separate from hypotheses; faster CPU numbers alone do not
   never deinitialises and fires every frame for the life of the process. Stop it wherever the owner is replaced (a
   `didSet` on the property), and count live ones for a test (`EdgeFrameTicker.live`). Find them in a sample of the
   idle app: `EdgeFrameTicker.step` under `CA::Display::DisplayLink` with nothing animating.
+- **A posted click on a hidden test window never reaches a SwiftUI gesture.** The window is not key, so AppKit
+  treats the click as the first mouse and drops it before SwiftUI sees it: a plain `Button` and an `.onTapGesture` both
+  stayed silent, while a click on a `TextField` worked (it is an AppKit view, hit-tested directly), which made the
+  harness look fine. Making the test window key would take the user's keyboard. Host the view in an `NSHostingView`
+  subclass whose `acceptsFirstMouse` returns true (`FirstClickHost` in WidgetInboxTasksPolishTests); that is how a
+  key panel delivers it. Prove the harness with a control (a `Button` that must fire) before you call a dead click
+  a bug.
 
 ## Hangs that reached the user on 2026-10-23, and why they got through — 2026-10-23 21:13
 
@@ -481,6 +488,13 @@ Keep measured findings separate from hypotheses; faster CPU numbers alone do not
   while the output device was slow, every typing pause, and a tap that waits delays every key in every app. Start it
   on its own queue and play the first click when it runs; keep the synchronous start only for offline rendering in
   tests (`isInManualRenderingMode`).
+- **Moving a start off the main thread is not enough when the main thread then asks the same object.**
+  `AVAudioEngine.isRunning` takes the engine lock that `start()` holds on the other queue, so the first fix still
+  blocked the key tap for the whole start (21:14). Keep the state yourself (`running`, `starting`). The same holds
+  for `NSSound.play()`: it waits for the output device, 0.8 s in the widget's alert; play it from a queue.
+- **The first read of `AVAudioEngine.mainMixerNode` creates the output unit and waits for CoreAudio too.** Clicky
+  wired its voices to the mixer in `init`, which cost 0.5 s on the main thread every time the settings face launched
+  (21:30). Create the nodes in `init`, attach and connect them on the start queue just before the first `start()`.
 
 ## A button that works once, and pictures that come out white — 2026-10-23 22:44
 
diff --git a/src/macos/GenesisKit/README.md b/src/macos/GenesisKit/README.md
index 30ebc89db6..e81ad76ae3 100644
--- a/src/macos/GenesisKit/README.md
+++ b/src/macos/GenesisKit/README.md
@@ -1541,16 +1541,23 @@ InfoStrip(
 
 #### `NoticePill`
 
-A short status line: an icon, a message and an optional dim detail line. A close icon is always shown. A success notice calls `dismiss` six seconds after it appears (the timer restarts when `text` changes); an error stays until the person dismisses it. The text wraps rather than ending in an ellipsis, and it can be selected and copied.
+A status line: an icon, a message, an optional dim detail line, the ways to fix what it reports, and the full message behind "Details". A success notice without fixes calls `dismiss` six seconds after it appears (the timer restarts when `text` changes); an error, a warning, or a notice with a fix stays until the person dismisses it or it no longer applies. The text wraps rather than ending in an ellipsis, and it can be selected and copied.
 
 - `text: String`: the message.
 - `detail: String? = nil`: a dimmer second line.
-- `isError: Bool = false`: shows a red warning icon and keeps the pill on screen.
-- `dismiss: () -> Void`: called by the close icon, and by the timer for a success notice. The host removes the pill in it.
+- `more: String? = nil`: the full message (stderr, a stack, a path list), shown behind a "Details" disclosure.
+- `tone: NoticePill.Tone`: `.success` (green check), `.warning` (amber) or `.error` (red). The older `isError: Bool` initializer maps to `.error` or `.success`.
+- `fixes: [NoticeFix] = []`: one row per fix.
+  - `NoticeFix.button(_ label:symbol:confirm:perform:)`: the label says what a press does ("Quit the older Genesis (pid 1234)"). With `confirm:` (a `NoticeFix.Confirmation` with the question, an optional consequence and the confirming label) the notice asks inside itself before it acts, so the question also works in a panel that never becomes key.
+  - `NoticeFix.command(_ label:, _ command:)`: a command for the person's terminal; the notice shows it and copies it.
+- `dismiss: (() -> Void)? = nil`: called by the close icon, and by the timer for a success notice. The host removes the pill in it.
 
 ```swift
 if let notice {
-    NoticePill(text: notice.text, detail: notice.detail, isError: notice.isError) {
+    NoticePill(text: notice.text, detail: notice.detail, more: notice.stderr, tone: .warning, fixes: [
+        .button("Quit the older Genesis (pid \(pid))", confirm: .init("Quit it?", confirmLabel: "Quit")) { quit(pid) },
+        .command("Or from a terminal", "kill \(pid)"),
+    ]) {
         self.notice = nil
     }
 }
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Audio/AudioOutputs.swift b/src/macos/GenesisKit/Sources/GenesisKit/Audio/AudioOutputs.swift
new file mode 100644
index 0000000000..bf36ac5fe2
--- /dev/null
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Audio/AudioOutputs.swift
@@ -0,0 +1,164 @@
+import AVFoundation
+import AudioToolbox
+import CoreAudio
+import Foundation
+
+/// One audio output of this Mac, with the delay macOS reports for it.
+public struct AudioOutputDevice: Identifiable, Hashable, Sendable {
+    public let id: AudioDeviceID
+    public let uid: String
+    public let name: String
+    public let transport: UInt32
+    /// Device latency + safety offset + stream latency + one IO buffer, as CoreAudio reports them, in seconds. An AirPlay
+    /// output (a HomePod) reports about 2 s; built-in speakers about 0.03 s (measured 2026-10-25).
+    public let delay: TimeInterval
+
+    public init(id: AudioDeviceID, uid: String, name: String, transport: UInt32, delay: TimeInterval) {
+        self.id = id
+        self.uid = uid
+        self.name = name
+        self.transport = transport
+        self.delay = delay
+    }
+
+    public var isVirtual: Bool {
+        transport == kAudioDeviceTransportTypeVirtual || transport == kAudioDeviceTransportTypeAggregate
+            || transport == kAudioDeviceTransportTypeAutoAggregate
+    }
+
+    public var isBuiltIn: Bool { transport == kAudioDeviceTransportTypeBuiltIn }
+
+    /// "2.0 s late" or "27 ms late".
+    public var delayText: String { Self.delayText(delay) }
+
+    public static func delayText(_ seconds: TimeInterval) -> String {
+        seconds >= 1 ? String(format: "%.1f s late", seconds) : "\(Int((seconds * 1000).rounded())) ms late"
+    }
+}
+
+/// The Mac's audio outputs, read from CoreAudio: the list, the system output, a faster alternative, and pinning an
+/// `AVAudioEngine` to one device. Clicky plays through it; any part that plays sound can.
+public enum AudioOutputs {
+    /// Every device with at least one output stream.
+    public static func outputs() -> [AudioOutputDevice] {
+        var address = AudioObjectPropertyAddress(
+            mSelector: kAudioHardwarePropertyDevices, mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain)
+        var size: UInt32 = 0
+        let system = AudioObjectID(kAudioObjectSystemObject)
+        guard AudioObjectGetPropertyDataSize(system, &address, 0, nil, &size) == noErr else { return [] }
+        var ids = [AudioDeviceID](repeating: 0, count: Int(size) / MemoryLayout<AudioDeviceID>.size)
+        guard AudioObjectGetPropertyData(system, &address, 0, nil, &size, &ids) == noErr else { return [] }
+        return ids.compactMap(device(for:))
+    }
+
+    public static func systemDefaultID() -> AudioDeviceID? {
+        var address = AudioObjectPropertyAddress(
+            mSelector: kAudioHardwarePropertyDefaultOutputDevice, mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain)
+        var id = AudioDeviceID(0)
+        var size = UInt32(MemoryLayout<AudioDeviceID>.size)
+        guard AudioObjectGetPropertyData(AudioObjectID(kAudioObjectSystemObject), &address, 0, nil, &size, &id) == noErr,
+              id != 0 else { return nil }
+        return id
+    }
+
+    /// An output to offer instead of a late one: the built-in speakers, else the connected output with the least delay.
+    /// Virtual and aggregate devices are never offered: they may not reach a speaker.
+    public static func suggestion(instead late: AudioOutputDevice, outputs: [AudioOutputDevice],
+                                  limit: TimeInterval) -> AudioOutputDevice? {
+        let candidates = outputs.filter { $0.uid != late.uid && !$0.isVirtual && $0.delay < limit }
+        return candidates.first(where: \.isBuiltIn) ?? candidates.min { $0.delay < $1.delay }
+    }
+
+    /// Makes `engine` play on `device` from its next start (call it while the engine is stopped). Returns false when
+    /// CoreAudio refused or the engine renders offline.
+    @discardableResult
+    public static func pin(_ engine: AVAudioEngine, to device: AudioDeviceID) -> Bool {
+        guard !engine.isInManualRenderingMode, let unit = engine.outputNode.audioUnit else { return false }
+        var device = device
+        return AudioUnitSetProperty(unit, kAudioOutputUnitProperty_CurrentDevice, kAudioUnitScope_Global, 0, &device,
+                                    UInt32(MemoryLayout<AudioDeviceID>.size)) == noErr
+    }
+
+    // MARK: - CoreAudio
+
+    private static func device(for id: AudioDeviceID) -> AudioOutputDevice? {
+        let streams = outputStreams(id)
+        guard !streams.isEmpty, let uid = string(id, kAudioDevicePropertyDeviceUID) else { return nil }
+        let output = kAudioObjectPropertyScopeOutput
+        let global = kAudioObjectPropertyScopeGlobal
+        let rate = value(id, kAudioDevicePropertyNominalSampleRate, global, Float64(0)) ?? 0
+        let frames = (value(id, kAudioDevicePropertyLatency, output, UInt32(0)) ?? 0)
+            + (value(id, kAudioDevicePropertySafetyOffset, output, UInt32(0)) ?? 0)
+            + (value(id, kAudioDevicePropertyBufferFrameSize, global, UInt32(0)) ?? 0)
+            + (value(streams[0], kAudioStreamPropertyLatency, global, UInt32(0)) ?? 0)
+        return AudioOutputDevice(
+            id: id, uid: uid, name: string(id, kAudioDevicePropertyDeviceNameCFString) ?? "Output",
+            transport: value(id, kAudioDevicePropertyTransportType, global, UInt32(0)) ?? 0,
+            delay: rate > 0 ? Double(frames) / rate : 0)
+    }
+
+    private static func outputStreams(_ id: AudioDeviceID) -> [AudioStreamID] {
+        var address = AudioObjectPropertyAddress(
+            mSelector: kAudioDevicePropertyStreams, mScope: kAudioObjectPropertyScopeOutput,
+            mElement: kAudioObjectPropertyElementMain)
+        var size: UInt32 = 0
+        guard AudioObjectGetPropertyDataSize(id, &address, 0, nil, &size) == noErr, size > 0 else { return [] }
+        var streams = [AudioStreamID](repeating: 0, count: Int(size) / MemoryLayout<AudioStreamID>.size)
+        guard AudioObjectGetPropertyData(id, &address, 0, nil, &size, &streams) == noErr else { return [] }
+        return streams
+    }
+
+    private static func value<T: BinaryInteger & Sendable>(_ id: AudioObjectID, _ selector: AudioObjectPropertySelector,
+                                                           _ scope: AudioObjectPropertyScope, _ initial: T) -> T? {
+        var address = AudioObjectPropertyAddress(mSelector: selector, mScope: scope, mElement: kAudioObjectPropertyElementMain)
+        var result = initial
+        var size = UInt32(MemoryLayout<T>.size)
+        return AudioObjectGetPropertyData(id, &address, 0, nil, &size, &result) == noErr ? result : nil
+    }
+
+    private static func value(_ id: AudioObjectID, _ selector: AudioObjectPropertySelector,
+                              _ scope: AudioObjectPropertyScope, _ initial: Float64) -> Float64? {
+        var address = AudioObjectPropertyAddress(mSelector: selector, mScope: scope, mElement: kAudioObjectPropertyElementMain)
+        var result = initial
+        var size = UInt32(MemoryLayout<Float64>.size)
+        return AudioObjectGetPropertyData(id, &address, 0, nil, &size, &result) == noErr ? result : nil
+    }
+
+    private static func string(_ id: AudioObjectID, _ selector: AudioObjectPropertySelector) -> String? {
+        var address = AudioObjectPropertyAddress(
+            mSelector: selector, mScope: kAudioObjectPropertyScopeGlobal, mElement: kAudioObjectPropertyElementMain)
+        var text: Unmanaged<CFString>?
+        var size = UInt32(MemoryLayout<Unmanaged<CFString>?>.size)
+        guard AudioObjectGetPropertyData(id, &address, 0, nil, &size, &text) == noErr, let text else { return nil }
+        return text.takeRetainedValue() as String
+    }
+}
+
+/// Calls `changed` on the main queue when the system output or the list of devices changes.
+@MainActor
+public final class AudioOutputMonitor {
+    private var listeners: [(AudioObjectPropertyAddress, AudioObjectPropertyListenerBlock)] = []
+
+    public init(changed: @escaping @MainActor () -> Void) {
+        for selector in [kAudioHardwarePropertyDefaultOutputDevice, kAudioHardwarePropertyDevices] {
+            var address = AudioObjectPropertyAddress(
+                mSelector: selector, mScope: kAudioObjectPropertyScopeGlobal, mElement: kAudioObjectPropertyElementMain)
+            let block: AudioObjectPropertyListenerBlock = { _, _ in
+                MainActor.assumeIsolated { changed() }
+            }
+            if AudioObjectAddPropertyListenerBlock(AudioObjectID(kAudioObjectSystemObject), &address, .main, block) == noErr {
+                listeners.append((address, block))
+            }
+        }
+    }
+
+    public func stop() {
+        for (address, block) in listeners {
+            var address = address
+            AudioObjectRemovePropertyListenerBlock(AudioObjectID(kAudioObjectSystemObject), &address, .main, block)
+        }
+        listeners.removeAll()
+    }
+}
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Charts/NativeCharts.swift b/src/macos/GenesisKit/Sources/GenesisKit/Charts/NativeCharts.swift
index d8f1e2c20e..fac6cb231c 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Charts/NativeCharts.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Charts/NativeCharts.swift
@@ -4,11 +4,23 @@ import SwiftUI
 public struct NativeTimePoint: Identifiable, Equatable, Sendable {
     public var date: Date
     public var value: Double
+    /// The denominator behind a rate. Counts ignore it; averages preserve it when bins merge.
+    public var weight: Double
     public var id: Date { date }
-    public init(date: Date, value: Double) { self.date = date; self.value = value }
+    public init(date: Date, value: Double, weight: Double = 1) { self.date = date; self.value = value; self.weight = weight }
 }
 
 public enum NativeChartSampling {
+    static func zoomFraction(_ zoom: Double, minimum: Double, maximum: Double) -> Double {
+        guard maximum > minimum else { return 0 }
+        return min(1, max(0, log(max(1, zoom / minimum)) / log(maximum / minimum)))
+    }
+
+    /// Grouped points may start before the picked interval, such as its first partial week.
+    static func fittedStart(_ start: Date, firstPoint: Date?) -> Date {
+        min(start, firstPoint ?? start)
+    }
+
     public static func pannedPosition(origin: Date, translation: Double, width: Double,
         window: TimeInterval, domain: ClosedRange<Date>) -> Date {
         clampedPosition(origin.addingTimeInterval(-translation / max(1, width) * window), window: window, domain: domain)
@@ -33,29 +45,76 @@ public enum NativeChartSampling {
         return .dateTime.hour().minute()
     }
 
+    /// How a bin combines the points that fall into it: counts add up, rates and shares average.
+    public enum Combine: Sendable { case sum, average }
+
+    /// A calendar bin (a day or a week) follows the calendar: weeks start on the user's first weekday and a day
+    /// can be 23 or 25 hours long. Every other step is a fixed grid.
+    static func calendarComponent(for step: TimeInterval) -> Calendar.Component? {
+        step == 86400 ? .day : step == 604800 ? .weekOfYear : nil
+    }
+
+    /// The width of one drawn bin: `step`, or a multiple of it when the span would need more than 1,200 bins.
+    public static func binInterval(start: Date, end: Date, step: TimeInterval) -> TimeInterval {
+        if calendarComponent(for: step) != nil { return step }
+        return max(step, ceil(end.timeIntervalSince(start) / (step * 1200)) * step)
+    }
+
+    /// The span a bin covers, as a reader names it: "Mon, Oct 19 to Sun, Oct 25", "Mon, Oct 19, 2026",
+    /// "Oct 19, 14:00 to 15:00".
+    public static func spanText(_ date: Date, step: TimeInterval, calendar: Calendar = .current) -> String {
+        let day = Date.FormatStyle.dateTime.weekday(.abbreviated).month(.abbreviated).day()
+        if step >= 604800 {
+            let days = max(1, Int((step / 86400).rounded()))
+            let last = calendar.date(byAdding: .day, value: days - 1, to: date) ?? date
+            return "\(date.formatted(day)) to \(last.formatted(day))"
+        }
+        if step >= 86400 { return date.formatted(day.year()) }
+        let end = date.addingTimeInterval(step)
+        return "\(date.formatted(.dateTime.month(.abbreviated).day().hour().minute())) to \(end.formatted(.dateTime.hour().minute()))"
+    }
+
     public static func bins(points: [NativeTimePoint], start: Date, end: Date, step: TimeInterval,
-        calendar: Calendar = .current) -> [NativeTimePoint] {
+        calendar: Calendar = .current, combine: Combine = .sum) -> [NativeTimePoint] {
         guard let first = points.first, end > start, step > 0 else { return [] }
-        if step == 86400 {
-            var day = calendar.startOfDay(for: max(first.date, start))
-            let values = Dictionary(points.filter { $0.date >= day && $0.date < end }.map {
-                (calendar.startOfDay(for: $0.date), $0.value)
-            }, uniquingKeysWith: +)
+        if let component = calendarComponent(for: step) {
+            func key(_ date: Date) -> Date {
+                component == .day ? calendar.startOfDay(for: date)
+                    : calendar.dateInterval(of: .weekOfYear, for: date)?.start ?? calendar.startOfDay(for: date)
+            }
+            var cursor = key(max(first.date, start))
+            var sums: [Date: Double] = [:]
+            var counts: [Date: Double] = [:]
+            for point in points where point.date >= cursor && point.date < end {
+                let bin = key(point.date)
+                let weight = combine == .average ? max(0, point.weight) : 1
+                sums[bin, default: 0] += point.value * weight
+                counts[bin, default: 0] += weight
+            }
             var result: [NativeTimePoint] = []
-            while day < end && result.count < 1201 {
-                result.append(NativeTimePoint(date: day, value: values[day, default: 0]))
-                guard let next = calendar.date(byAdding: .day, value: 1, to: day), next > day else { break }
-                day = next
+            var visited = 0
+            while cursor < end && visited < 1201 {
+                visited += 1
+                if let count = counts[cursor], count > 0 {
+                    let sum = sums[cursor, default: 0]
+                    result.append(NativeTimePoint(date: cursor, value: combine == .sum ? sum : sum / count,
+                        weight: combine == .average ? count : 1))
+                } else if combine == .sum {
+                    result.append(NativeTimePoint(date: cursor, value: 0))
+                }
+                guard let next = calendar.date(byAdding: component, value: 1, to: cursor), next > cursor else { break }
+                cursor = next
             }
             return result
         }
-        let interval = max(step, ceil(end.timeIntervalSince(start) / (step * 1200)) * step)
+        let interval = binInterval(start: start, end: end, step: step)
         // Both bounds on the same interval grid, so a bin's time and count do not depend on where the view starts.
         let lower = max(floor(first.date.timeIntervalSince1970 / interval), floor(start.timeIntervalSince1970 / interval)) * interval
         let upper = end.timeIntervalSince1970
         guard lower < upper else { return [] }
         let count = min(1201, Int(ceil((upper - lower) / interval)))
         var values = Array(repeating: 0.0, count: count)
+        var counts = Array(repeating: 0.0, count: count)
         var low = 0
         var high = points.count
         while low < high {
@@ -66,15 +125,29 @@ public enum NativeChartSampling {
             let time = point.date.timeIntervalSince1970
             if time >= upper { break }
             let index = Int((time - lower) / interval)
-            if values.indices.contains(index) { values[index] += point.value }
+            if values.indices.contains(index) {
+                let weight = combine == .average ? max(0, point.weight) : 1
+                values[index] += point.value * weight
+                counts[index] += weight
+            }
+        }
+        return values.indices.compactMap { index in
+            let date = Date(timeIntervalSince1970: lower + Double(index) * interval)
+            switch combine {
+            case .sum: return NativeTimePoint(date: date, value: values[index])
+            case .average:
+                return counts[index] > 0 ? NativeTimePoint(date: date, value: values[index] / counts[index], weight: counts[index]) : nil
+            }
         }
-        return values.enumerated().map { NativeTimePoint(
-            date: Date(timeIntervalSince1970: lower + Double($0.offset) * interval), value: $0.element) }
     }
 }
 
+/// A pannable, zoomable time series. Two ways to open:
+/// - `rangeStart: nil`: on the latest `initialWindow`, zoomable from a quarter to 8 times that window.
+/// - `rangeStart` set: fitted to the whole `rangeStart...end`; zoom goes from that whole range down to 5 bins, and
+///   "Whole range" returns to it.
 public struct NativeTimeSeriesChart: View {
-    public enum Style: String, CaseIterable, Identifiable {
+    public enum Style: String, CaseIterable, Identifiable, Sendable {
         case line = "Line", area = "Area", bars = "Bars"
         public var id: Self { self }
     }
@@ -83,7 +156,11 @@ public struct NativeTimeSeriesChart: View {
     private let initialWindow: TimeInterval
     private let valueLabel: String
     private let end: Date
-    @State private var style: Style = .area
+    private let rangeStart: Date?
+    private let combine: NativeChartSampling.Combine
+    private let valueFormat: ((Double) -> String)?
+    private let styleBinding: Binding<Style>?
+    @State private var ownStyle: Style = .area
     @State private var zoom = 1.0
     @State private var position: Date
     @State private var selected: Date?
@@ -91,49 +168,110 @@ public struct NativeTimeSeriesChart: View {
     @State private var plotWidth: CGFloat = 1
     @GestureState private var dragging = false
 
+    /// - Parameters:
+    ///   - rangeStart: the start of the period the page shows; the chart opens fitted to `rangeStart...end`.
+    ///   - combine: how wide views merge bins; `.average` for rates and shares, which must not add up.
+    ///   - valueFormat: how a value reads in the hover text and on the Y axis ("1h 5m", "12.5%").
+    ///   - style: where the Line, Area or Bars choice is kept; without it the choice lives as long as the view.
     public init(points: [NativeTimePoint], interval: TimeInterval, initialWindow: TimeInterval,
-        end: Date = Date(), valueLabel: String = "Events") {
+        end: Date = Date(), valueLabel: String = "Events", rangeStart: Date? = nil,
+        combine: NativeChartSampling.Combine = .sum, valueFormat: ((Double) -> String)? = nil,
+        style: Binding<Style>? = nil) {
         self.points = points
         self.interval = interval
         self.initialWindow = initialWindow
         self.valueLabel = valueLabel
         self.end = end
-        _position = State(initialValue: end.addingTimeInterval(-initialWindow))
+        self.rangeStart = rangeStart
+        self.combine = combine
+        self.valueFormat = valueFormat
+        styleBinding = style
+        let start = rangeStart.map {
+            min(NativeChartSampling.fittedStart($0, firstPoint: points.first?.date), end.addingTimeInterval(-interval * 5))
+        }
+        _position = State(initialValue: start ?? end.addingTimeInterval(-initialWindow))
+    }
+
+    private var style: Binding<Style> { styleBinding ?? $ownStyle }
+    private var fitted: Bool { rangeStart != nil }
+    private var minimumWindow: TimeInterval { interval * 5 }
+    /// The whole range in fitted mode.
+    private var span: TimeInterval {
+        guard let rangeStart else { return initialWindow }
+        return max(minimumWindow, end.timeIntervalSince(NativeChartSampling.fittedStart(rangeStart, firstPoint: points.first?.date)))
+    }
+    private var maxZoom: Double { fitted ? max(1, span / minimumWindow) : 8 }
+    private var minZoom: Double { fitted ? 1 : 0.25 }
+    private var window: TimeInterval {
+        fitted ? min(span, max(minimumWindow, span / zoom)) : max(minimumWindow, initialWindow / zoom)
     }
-    private var window: TimeInterval { max(interval * 5, initialWindow / zoom) }
     private var domain: ClosedRange<Date> {
+        if fitted { return end.addingTimeInterval(-span)...end }
         let first = points.first?.date ?? end.addingTimeInterval(-initialWindow)
         return min(first, end.addingTimeInterval(-window))...end
     }
+    private var visibleStart: Date { max(domain.lowerBound, position.addingTimeInterval(-window / 4)) }
+    private var visibleEnd: Date { min(end, position.addingTimeInterval(window * 1.25)) }
     private var visible: [NativeTimePoint] {
-        NativeChartSampling.bins(points: points, start: position.addingTimeInterval(-window / 4),
-            end: min(end, position.addingTimeInterval(window * 1.25)), step: interval)
+        NativeChartSampling.bins(points: points, start: visibleStart, end: visibleEnd, step: interval, combine: combine)
+    }
+    private var binWidth: TimeInterval {
+        NativeChartSampling.binInterval(start: visibleStart, end: visibleEnd, step: interval)
     }
     private var selectedPoint: NativeTimePoint? {
         guard let selected else { return nil }
         return visible.min { abs($0.date.timeIntervalSince(selected)) < abs($1.date.timeIntervalSince(selected)) }
     }
+    private func format(_ value: Double) -> String { valueFormat?(value) ?? NativeChartSampling.valueText(value) }
+    /// The zoom on a log scale, so one slider spans "whole two years" to "five bins" evenly.
+    private var zoomSlider: Binding<Double> {
+        Binding(get: { NativeChartSampling.zoomFraction(zoom, minimum: minZoom, maximum: maxZoom) },
+            set: { zoom = minZoom * pow(maxZoom / minZoom, $0) })
+    }
+    private func pan(by fraction: Double) {
+        position = NativeChartSampling.clampedPosition(position.addingTimeInterval(window * fraction), window: window, domain: domain)
+        selected = nil
+    }
+    private var shownSpan: String {
+        let last = min(end, position.addingTimeInterval(window))
+        let days = window >= 86400 * 2
+        let first: Date.FormatStyle = days ? .dateTime.year().month(.abbreviated).day()
+            : .dateTime.year().month(.abbreviated).day().hour().minute()
+        let second: Date.FormatStyle = days ? .dateTime.year().month(.abbreviated).day()
+            : .dateTime.month(.abbreviated).day().hour().minute()
+        return "\(position.formatted(first)) to \(last.formatted(second))"
+    }
+
     public var body: some View {
         VStack(alignment: .leading, spacing: 12) {
-            HStack {
-                Picker("Chart style", selection: $style) {
+            HStack(spacing: 6) {
+                Picker("Chart style", selection: style) {
                     ForEach(Style.allCases) { Text($0.rawValue).tag($0) }
                 }.pickerStyle(.segmented).labelsHidden().frame(width: 210, alignment: .leading)
                 Spacer()
-                Button { zoom = max(0.25, zoom / 2) } label: { Image(systemName: "minus.magnifyingglass").frame(width: 26, height: 26).contentShape(Rectangle()) }
-                    .accessibilityLabel("Zoom out chart")
-                Slider(value: $zoom, in: 0.25...8).frame(width: 90).accessibilityLabel("Chart zoom")
-                Button { zoom = min(8, zoom * 2) } label: { Image(systemName: "plus.magnifyingglass").frame(width: 26, height: 26).contentShape(Rectangle()) }
-                    .accessibilityLabel("Zoom in chart")
+                IconButton(systemName: "chevron.left", tooltip: "Earlier (Left Arrow)") { pan(by: -0.5) }
+                IconButton(systemName: "chevron.right", tooltip: "Later (Right Arrow)") { pan(by: 0.5) }
+                IconButton(systemName: "minus.magnifyingglass", tooltip: "Zoom out chart") { zoom = max(minZoom, zoom / 2) }
+                Slider(value: zoomSlider, in: 0...1).frame(width: 90).accessibilityLabel("Chart zoom")
+                    .help("Chart zoom").disabled(maxZoom <= minZoom)
+                IconButton(systemName: "plus.magnifyingglass", tooltip: "Zoom in chart") { zoom = min(maxZoom, zoom * 2) }
+                if fitted {
+                    Button("Whole range") {
+                        zoom = 1
+                        position = domain.lowerBound
+                    }.buttonStyle(.genHover()).help("Show the whole selected range")
+                        .disabled(zoom <= 1.0001)
+                }
                 Button("Latest") { position = max(domain.lowerBound, end.addingTimeInterval(-window)) }
-            }.buttonStyle(.borderless)
+                    .buttonStyle(.genHover()).help("Show the most recent part")
+            }
             plot.frame(height: 235)
             HStack {
                 if let point = selectedPoint {
-                    Text("\(point.date.formatted(date: .abbreviated, time: .shortened)) · \(NativeChartSampling.valueText(point.value)) \(valueLabel.lowercased())")
-                } else { Text("Drag or scroll to explore. Hover to inspect a value.") }
+                    Text("\(NativeChartSampling.spanText(point.date, step: binWidth)): \(format(point.value)) \(valueLabel.lowercased())")
+                } else { Text("Drag, scroll or use the arrow keys to explore. Hover to inspect a value.") }
                 Spacer()
-                Text(position.formatted(date: .abbreviated, time: .shortened)).monospacedDigit()
+                Text(shownSpan).monospacedDigit()
             }.font(.caption).foregroundStyle(.secondary)
         }
         // A new period (custom dates, a refreshed report) or zoom keeps the view on data: a position left over from
@@ -141,10 +279,13 @@ public struct NativeTimeSeriesChart: View {
         .onChange(of: zoom) { _, _ in position = NativeChartSampling.clampedPosition(position, window: window, domain: domain) }
         .onChange(of: domain) { _, value in position = NativeChartSampling.clampedPosition(position, window: window, domain: value) }
     }
+
     private var plot: some View {
-        Chart {
-            ForEach(visible) { point in
-                switch style {
+        let shown = visible
+        let peak = shown.map(\.value).max() ?? 0
+        return Chart {
+            ForEach(shown) { point in
+                switch style.wrappedValue {
                 case .line:
                     LineMark(x: .value("Time", point.date), y: .value(valueLabel, point.value))
                         .foregroundStyle(.mint).interpolationMethod(.linear)
@@ -157,16 +298,22 @@ public struct NativeTimeSeriesChart: View {
                     BarMark(x: .value("Time", point.date), y: .value(valueLabel, point.value)).foregroundStyle(.mint)
                 }
             }
-            if visible.count == 1, let point = visible.first {
+            if shown.count == 1, let point = shown.first {
                 PointMark(x: .value("Time", point.date), y: .value(valueLabel, point.value))
                     .foregroundStyle(.mint).symbolSize(36)
             }
             if let point = selectedPoint {
                 RuleMark(x: .value("Selected time", point.date)).foregroundStyle(.secondary).lineStyle(StrokeStyle(dash: [3]))
+                    .annotation(position: .top, spacing: 0,
+                        overflowResolution: .init(x: .fit(to: .chart), y: .fit(to: .chart))) {
+                        Text(format(point.value)).font(.caption.weight(.semibold)).monospacedDigit()
+                            .padding(.horizontal, 6).padding(.vertical, 2)
+                            .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 5))
+                    }
             }
         }
         .chartXScale(domain: domain)
-        .chartYScale(domain: 0...max(1, (visible.map(\.value).max() ?? 0) * 1.12))
+        .chartYScale(domain: 0...max(1, peak * 1.12))
         .chartScrollableAxes(.horizontal)
         .chartXVisibleDomain(length: window)
         .chartScrollPosition(x: $position)
@@ -188,7 +335,17 @@ public struct NativeTimeSeriesChart: View {
                 selected = nil
             })
         .onChange(of: dragging) { _, active in if !active { panOrigin = nil } }
-        .chartYAxis { AxisMarks(position: .leading) }
+        .chartYAxis {
+            AxisMarks(position: .leading) { value in
+                AxisGridLine()
+                AxisTick()
+                if let valueFormat {
+                    AxisValueLabel { if let number = value.as(Double.self) { Text(valueFormat(number)) } }
+                } else {
+                    AxisValueLabel()
+                }
+            }
+        }
         .chartXAxis {
             AxisMarks(values: .automatic(desiredCount: 4)) {
                 AxisGridLine()
@@ -196,7 +353,11 @@ public struct NativeTimeSeriesChart: View {
                 AxisValueLabel(format: NativeChartSampling.axisLabelFormat(interval: interval, window: window))
             }
         }
-        .accessibilityLabel("\(valueLabel) timeline. Scroll horizontally to pan; use the zoom controls to change the visible range.")
+        .focusable()
+        .onKeyPress(.leftArrow) { pan(by: -0.25); return .handled }
+        .onKeyPress(.rightArrow) { pan(by: 0.25); return .handled }
+        .accessibilityLabel("\(valueLabel) timeline")
+        .accessibilityValue("\(shownSpan). \(shown.count) bars, highest \(format(peak)). Use the arrow keys to move earlier or later.")
     }
 }
 
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalytics.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalytics.swift
index 8bc2de367c..5cb6df1906 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalytics.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalytics.swift
@@ -112,6 +112,40 @@ extension ClickyStatistics {
             result.presses += presses
             result.releases += presses
         }
+        // Before the minute detail: two years of hourly and daily totals, as the retention keeps them, so the long
+        // ranges have something to show.
+        let oldest = calendar.date(byAdding: .day, value: -730, to: start) ?? start
+        let hourlyKeysFrom = calendar.date(byAdding: .day, value: -366, to: now) ?? start
+        result.startedAt = oldest
+        result.historyStartedAt = oldest
+        result.performanceStartedAt = oldest
+        var hourDate = oldest
+        var index = 0
+        while hourDate < start {
+            let hourOfDay = calendar.component(.hour, from: hourDate)
+            let weekday = calendar.component(.weekday, from: hourDate)
+            let season = 0.75 + 0.25 * sin(Double(index) / 900)
+            let factor = (weekday == 1 || weekday == 7 ? 0.3 : 1.0) * ((8..<22).contains(hourOfDay) ? 1.0 : 0.05) * season
+            let presses = Int((900 + 2400 * abs(sin(Double(index) / 29))) * factor)
+            index += 1
+            defer { hourDate = hourDate.addingTimeInterval(3600) }
+            guard presses > 0 else { continue }
+            let hour = Int(hourDate.timeIntervalSince1970 / 3600)
+            let day = Int(calendar.startOfDay(for: hourDate).timeIntervalSince1970)
+            if hourDate >= hourlyKeysFrom { result.hours[hour] = ClickyActivityBucket(presses: presses, releases: presses) }
+            result.days[day, default: ClickyActivityBucket()].presses += presses
+            result.days[day, default: ClickyActivityBucket()].releases += presses
+            var performance = ClickyPerformanceBucket()
+            performance.presses = presses
+            performance.characters = Int(Double(presses) * 0.8)
+            performance.corrections = Int(Double(presses) * (0.04 + 0.02 * season))
+            performance.activeSeconds = Double(performance.characters) / (3.6 + 0.6 * season)
+            performance.bursts = max(1, presses / 40)
+            performance.sessions = max(1, presses / 300)
+            result.performanceHours[hour] = performance
+            result.presses += presses
+            result.releases += presses
+        }
         let positions = ClickyKeyLayout.rows.flatMap { $0 }
         let weights = positions.enumerated().map { ($0.element.code, 1 + ($0.offset * 13) % 31) }
         let total = weights.reduce(0) { $0 + $1.1 }
@@ -135,3 +169,139 @@ public enum ClickyKeyLayout {
         rows.lazy.flatMap { $0 }.first { $0.code == code }?.label ?? "Key \(code)"
     }
 }
+
+/// Everything the Stats page shows for one range, built off the main thread once per refresh instead of in the view
+/// body on every published second.
+struct ClickyStatsReport: Sendable {
+    var interval = DateInterval()
+    var total = 0
+    var previousTotal: Int?
+    var approximateTotals = false
+    var totalDays = 0
+    var coveredDays = 0
+    var activeDays = 0
+    var records = ClickyRecords(days: [:], today: Date())
+    var busiestHour: Date?
+    var busiestHourValue = 0
+    var peakMinute: Date?
+    var peakMinuteValue = 0
+    var timeline: [NativeTimePoint] = []
+    var dayTimeline: [NativeTimePoint] = []
+    /// Hour-of-day by weekday, rows in the calendar's weekday order.
+    var heatmap: [NativeHeatmapCell] = []
+    /// Average presses per occurrence of each weekday in the range, Monday-based.
+    var weekdayAverages = Array(repeating: 0.0, count: 7)
+    var loaded = false
+
+    init() {}
+
+    var dailyAverage: Double { coveredDays > 0 ? Double(total) / Double(coveredDays) : 0 }
+
+    init(statistics: ClickyStatistics, interval: DateInterval, previous: DateInterval?,
+        resolution: ClickyTimeResolution, releases: Bool, now: Date, calendar: Calendar = .current) {
+        self.interval = interval
+        loaded = true
+        let earliest = ClickyRetention.historyStart(statistics, now: now, calendar: calendar)
+        totalDays = ClickyRanges.dayCount(interval, calendar: calendar)
+        coveredDays = ClickyRanges.coveredDays(interval, earliest: earliest, calendar: calendar)
+        let minuteRetention = floor(now.timeIntervalSince1970 / 3600) * 3600 - 30 * 86400
+        let hourRetention = floor(now.timeIntervalSince1970 / 3600) * 3600 - 366 * 86400
+        func presses(in range: DateInterval) -> (count: Int, approximate: Bool) {
+            var count = 0
+            var approximate = false
+            for (key, bucket) in statistics.days {
+                let day = Date(timeIntervalSince1970: Double(key))
+                let dayEnd = calendar.date(byAdding: .day, value: 1, to: day) ?? day.addingTimeInterval(86400)
+                guard day < range.end, dayEnd > range.start else { continue }
+                if day >= range.start && dayEnd <= range.end {
+                    count += bucket.presses
+                } else if day.timeIntervalSince1970 >= hourRetention {
+                    for (hour, hourly) in statistics.hours {
+                        let start = Double(hour) * 3600
+                        let end = start + 3600
+                        guard start >= day.timeIntervalSince1970, start < dayEnd.timeIntervalSince1970,
+                            start < range.end.timeIntervalSince1970, end > range.start.timeIntervalSince1970 else { continue }
+                        if start >= range.start.timeIntervalSince1970 && end <= range.end.timeIntervalSince1970 {
+                            count += hourly.presses
+                        } else if start >= minuteRetention {
+                            count += statistics.minutes.reduce(0) { sum, entry in
+                                let date = Date(timeIntervalSince1970: Double(entry.key) * 60)
+                                return entry.key / 60 == hour && date >= range.start && date < range.end
+                                    ? sum + entry.value.presses : sum
+                            }
+                        } else {
+                            count += hourly.presses
+                            approximate = true
+                        }
+                    }
+                } else {
+                    count += bucket.presses
+                    approximate = true
+                }
+            }
+            return (count, approximate)
+        }
+        let current = presses(in: interval)
+        total = current.count
+        approximateTotals = current.approximate
+        if let previous, let earliest, earliest < previous.end {
+            let comparison = presses(in: previous)
+            previousTotal = comparison.count
+            approximateTotals = approximateTotals || comparison.approximate
+        }
+
+        var daily: [Date: Double] = [:]
+        for (key, bucket) in statistics.days {
+            let day = Date(timeIntervalSince1970: Double(key))
+            guard day >= calendar.startOfDay(for: interval.start), day < interval.end else { continue }
+            daily[day] = Double(bucket.presses)
+        }
+        activeDays = daily.values.filter { $0 > 0 }.count
+        records = ClickyRecords(days: daily, today: now, calendar: calendar)
+        dayTimeline = daily.map { NativeTimePoint(date: $0.key, value: $0.value) }.sorted { $0.date < $1.date }
+
+        var cells: [Int: Double] = [:]
+        for (key, bucket) in statistics.hours {
+            let date = Date(timeIntervalSince1970: Double(key) * 3600)
+            guard interval.contains(date), date < interval.end else { continue }
+            if bucket.presses > busiestHourValue { busiestHourValue = bucket.presses; busiestHour = date }
+            cells[ClickyWeekdays.index(of: date, calendar: calendar) * 24 + calendar.component(.hour, from: date),
+                default: 0] += Double(bucket.presses)
+        }
+        let order = ClickyWeekdays.order(calendar)
+        heatmap = order.enumerated().flatMap { row, weekday in
+            (0..<24).map { NativeHeatmapCell(row: row, column: $0, value: cells[weekday * 24 + $0, default: 0]) }
+        }
+        var occurrences = Array(repeating: 0, count: 7)
+        if let earliest, coveredDays > 0 {
+            var day = max(calendar.startOfDay(for: interval.start), calendar.startOfDay(for: earliest))
+            while day < interval.end {
+                occurrences[ClickyWeekdays.index(of: day, calendar: calendar)] += 1
+                guard let next = calendar.date(byAdding: .day, value: 1, to: day) else { break }
+                day = next
+            }
+        }
+        var weekdayTotals = Array(repeating: 0.0, count: 7)
+        for (day, value) in daily { weekdayTotals[ClickyWeekdays.index(of: day, calendar: calendar)] += value }
+        weekdayAverages = (0..<7).map { occurrences[$0] > 0 ? weekdayTotals[$0] / Double(occurrences[$0]) : 0 }
+
+        let firstMinute = Int(floor(interval.start.timeIntervalSince1970 / 60))
+        for (minute, bucket) in statistics.minutes where minute >= firstMinute && bucket.presses > peakMinuteValue {
+            peakMinuteValue = bucket.presses
+            peakMinute = Date(timeIntervalSince1970: Double(minute) * 60)
+        }
+        timeline = statistics.timeline(resolution, releases: releases).filter { $0.date >= interval.start }
+    }
+
+    static func prepare(statistics: ClickyStatistics, interval: DateInterval, previous: DateInterval?,
+        resolution: ClickyTimeResolution, releases: Bool, now: Date) async -> Self? {
+        let worker = Task.detached(priority: .userInitiated) {
+            PerfLog.span("clicky.stats.report", over: PerfLog.frameMs) {
+                Self(statistics: statistics, interval: interval, previous: previous, resolution: resolution,
+                    releases: releases, now: now)
+            }
+        }
+        let report = await withTaskCancellationHandler { await worker.value } onCancel: { worker.cancel() }
+        return Task.isCancelled ? nil : report
+    }
+}
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalyticsView.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalyticsView.swift
index ba12bf38ff..41df279b2f 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalyticsView.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAnalyticsView.swift
@@ -3,61 +3,87 @@ import SwiftUI
 @MainActor
 public struct ClickyAnalyticsView: View {
     @ObservedObject private var store: ClickyAnalyticsStore
-    @State private var tab = "Activity"
-    @State private var resolution: ClickyTimeResolution = .minute
+    private let status: ClickyRecordingStatus
+    private let fixRecording: (() -> Void)?
+    @AppStorage private var tab: String
+    @AppStorage private var storedRange: String
+    @AppStorage private var chartStyle: NativeTimeSeriesChart.Style
+    @State private var resolution: ClickyTimeResolution
     @State private var releases = false
     @State private var example: ClickyStatistics?
     @State private var exampleTime: Date?
     @State private var selectedKey: Int?
+    @State private var report = ClickyStatsReport()
+    @State private var previousName = ""
+    @State private var refresh = 0
+    @State private var refreshPending = false
+
+    /// - Parameters:
+    ///   - status: whether Clicky records right now; anything but `.recording` shows why under the title.
+    ///   - fixRecording: the action of the button beside that reason.
+    public init(store: ClickyAnalyticsStore, defaults: UserDefaults = .standard,
+        status: ClickyRecordingStatus = .recording, fixRecording: (() -> Void)? = nil) {
+        self.store = store
+        self.status = status
+        self.fixRecording = fixRecording
+        _tab = AppStorage(wrappedValue: "Activity", "clicky.stats.tab", store: defaults)
+        _storedRange = AppStorage(wrappedValue: ClickyRanges.week, "clicky.stats.range", store: defaults)
+        _chartStyle = AppStorage(wrappedValue: .area, "clicky.stats.chartStyle", store: defaults)
+        let range = ClickyRanges.known(defaults.string(forKey: "clicky.stats.range") ?? ClickyRanges.week,
+            allowed: ClickyRanges.presets)
+        _resolution = State(initialValue: ClickyRanges.resolution(for: range))
+    }
 
-    public init(store: ClickyAnalyticsStore) { self.store = store }
     private var data: ClickyStatistics { example ?? store.snapshot }
     private var now: Date { exampleTime ?? Date() }
-    private var today: [ClickyActivityBucket] {
-        let start = Int(Calendar.current.startOfDay(for: now).timeIntervalSince1970 / 60)
-        return data.minutes.filter { $0.key >= start }.map(\.value)
+    private var range: String { ClickyRanges.known(storedRange, allowed: ClickyRanges.presets) }
+    private var earliest: Date? {
+        ClickyRetention.historyStart(data, now: now)
     }
-    private var todayPresses: Int { today.reduce(0) { $0 + $1.presses } }
-    private var activeMinutes: Int { today.filter { $0.presses > 0 }.count }
+    private var interval: DateInterval { ClickyRanges.interval(range, now: now, earliest: earliest) }
     private var keyRanking: [(key: Int, value: Int)] {
         data.keys.sorted { $0.value == $1.value ? $0.key < $1.key : $0.value > $1.value }
     }
 
+    private struct Query: Equatable {
+        let range: String
+        let resolution: ClickyTimeResolution
+        let releases: Bool
+        let exampleTime: Date?
+        let refresh: Int
+    }
+
+    /// New key presses rebuild the page at most every 5 seconds, off the main thread.
+    private func scheduleRefresh() {
+        guard example == nil, !refreshPending else { return }
+        refreshPending = true
+        Task { @MainActor in
+            try? await Task.sleep(for: .seconds(5))
+            refreshPending = false
+            refresh &+= 1
+        }
+    }
+
     public var body: some View {
         VStack(alignment: .leading, spacing: 18) {
-            HStack {
-                VStack(alignment: .leading, spacing: 4) {
-                    Text("Your keyboard, over time").font(.system(size: 21, weight: .semibold, design: .rounded))
-                    Text(example == nil ? "Recorded locally · updates once a second while typing" : "Sample data · never saved to your statistics")
-                        .font(.caption).foregroundStyle(example == nil ? Color.secondary : .orange)
-                }
-                Spacer()
-                Button(example == nil ? "Explore sample data" : "Back to my data") {
-                    if example == nil {
-                        let reference = Date()
-                        exampleTime = reference
-                        example = ClickyStatistics.example(now: reference)
-                    } else {
-                        example = nil
-                        exampleTime = nil
-                    }
-                }.buttonStyle(.bordered).accessibilityIdentifier("clicky.stats.example")
+            header
+            if example == nil, let message = status.message {
+                ClickyRecordingBanner(message: message, actionTitle: status.actionTitle, action: fixRecording)
             }
-            HStack(spacing: 12) {
-                summary(example == nil ? "Today" : "Sample day", value: todayPresses.formatted(), symbol: "keyboard")
-                summary("Active minutes", value: activeMinutes.formatted(), symbol: "clock")
-                summary("Peak / minute", value: (today.map(\.presses).max() ?? 0).formatted(), symbol: "bolt")
-            }
-            Picker("Statistics view", selection: $tab) {
-                ForEach(["Activity", "Keys", "Rhythm"], id: \.self) { Text($0).tag($0) }
-            }.pickerStyle(.segmented).labelsHidden().accessibilityIdentifier("clicky.stats.view")
-            if data.historyStartedAt == nil {
+            if data.historyStartedAt == nil && example == nil {
                 NativeSettingsCard {
-                    Label("Detailed history starts with your next recorded key press.", systemImage: "chart.xyaxis.line")
-                    Text("Your existing \(data.presses.formatted()) lifetime presses are preserved. There is no historical timeline to reconstruct from those totals.")
-                        .font(.caption).foregroundStyle(.secondary)
+                    EmptyState(symbol: "chart.xyaxis.line",
+                        text: status == .recording ? "Detailed history starts with your next recorded key press."
+                            : "No detailed history yet.",
+                        detail: "Your existing \(data.presses.formatted()) lifetime presses are preserved. There is no historical timeline to reconstruct from those totals.",
+                        actionTitle: "Explore Sample Data", action: showExample)
                 }
             } else {
+                rangeRow
+                summary.redacted(reason: report.loaded ? [] : .placeholder)
+                Picker("Statistics view", selection: $tab) {
+                    ForEach(["Activity", "Keys", "Rhythm"], id: \.self) { Text($0).tag($0) }
+                }.pickerStyle(.segmented).labelsHidden().accessibilityIdentifier("clicky.stats.view")
                 switch tab {
                 case "Keys": keys
                 case "Rhythm": rhythm
@@ -65,27 +91,137 @@ public struct ClickyAnalyticsView: View {
                 }
             }
             HStack {
-                Text("\(data.presses.formatted()) lifetime presses · \(data.releases.formatted()) releases · \(data.sessions.formatted()) activations")
+                Text("\(data.presses.formatted()) lifetime presses, \(data.releases.formatted()) key releases, Clicky turned on \(data.sessions.formatted()) times")
                 Spacer()
                 if let since = data.historyStartedAt {
                     Text("History since \(since.formatted(date: .abbreviated, time: .shortened))")
                 }
-            }.font(.caption2).foregroundStyle(.secondary)
+            }.font(.caption).foregroundStyle(.secondary)
         }
-        // On the whole view, so every tab (Activity is the default) gets the once-a-second updates.
+        // On the whole view, so every tab (Activity is the default) gets the updates.
         .onAppear { store.attach() }
         .onDisappear { store.detach() }
+        .onChange(of: store.revision) { _, _ in scheduleRefresh() }
+        .task(id: Query(range: range, resolution: resolution, releases: releases, exampleTime: exampleTime, refresh: refresh)) {
+            let interval = interval
+            let previous = ClickyRanges.previous(interval, range: range)
+            let name = ClickyRanges.previousName(interval, range: range)
+            let built = await ClickyStatsReport.prepare(statistics: data, interval: interval, previous: previous,
+                resolution: resolution, releases: releases, now: now)
+            guard let built, !Task.isCancelled else { return }
+            report = built
+            previousName = name
+        }
+    }
+
+    private func showExample() {
+        let reference = Date()
+        exampleTime = reference
+        example = ClickyStatistics.example(now: reference)
+        AccessibilityNotification.Announcement("Showing sample data. It is never saved.").post()
     }
 
-    private func summary(_ title: String, value: String, symbol: String) -> some View {
+    private var header: some View {
+        HStack {
+            VStack(alignment: .leading, spacing: 4) {
+                Text("Your keyboard, over time").font(.system(size: 21, weight: .semibold, design: .rounded))
+                Text(example == nil
+                    ? (status == .recording ? "Recorded locally. Updates every few seconds while you type." : "Recorded locally. Recording is paused.")
+                    : "Sample data, never saved to your statistics")
+                    .font(.caption).foregroundStyle(example == nil ? Color.secondary : .orange)
+            }
+            Spacer()
+            Button(example == nil ? "Explore Sample Data" : "Back to My Data") {
+                if example == nil { showExample() } else {
+                    example = nil
+                    exampleTime = nil
+                    AccessibilityNotification.Announcement("Showing your data.").post()
+                }
+            }.buttonStyle(.bordered).accessibilityIdentifier("clicky.stats.example")
+        }
+    }
+
+    private var rangeRow: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            HStack {
+                Text("Date range").font(.system(size: 13, weight: .medium))
+                Spacer()
+                Picker("Date range", selection: Binding(get: { range }, set: { storedRange = $0 })) {
+                    ForEach(ClickyRanges.presets, id: \.self) { Text($0).tag($0) }
+                }.labelsHidden().frame(width: 150, alignment: .trailing)
+                    .accessibilityIdentifier("clicky.stats.range")
+                    .onChange(of: storedRange) { _, next in
+                        resolution = ClickyRanges.resolution(for: ClickyRanges.known(next, allowed: ClickyRanges.presets))
+                    }
+            }
+            if let coverage = ClickyRanges.coverageText(interval, earliest: earliest) {
+                Label(coverage, systemImage: "calendar.badge.clock").font(.caption).foregroundStyle(.secondary)
+            }
+            if report.approximateTotals {
+                Text("Totals and comparisons are approximate at partial hours or days where minute detail has expired.")
+                    .font(.caption).foregroundStyle(.secondary)
+            }
+        }
+    }
+
+    private var summary: some View {
+        let day = Date.FormatStyle.dateTime.weekday(.abbreviated).month(.abbreviated).day()
+        let previousAverage = report.previousTotal.map { Double($0) / Double(max(1, report.totalDays)) }
+        return Grid(horizontalSpacing: 12, verticalSpacing: 12) {
+            GridRow {
+                card("Presses", report.total.formatted(), "keyboard", rangeDetail,
+                    ClickyFormat.change(Double(report.total), report.previousTotal.map(Double.init), against: previousName))
+                card("Daily average", report.dailyAverage.formatted(.number.precision(.fractionLength(0))), "chart.bar",
+                    "Per recorded day", ClickyFormat.change(report.dailyAverage, previousAverage, against: previousName))
+                card("Active days", "\(report.activeDays) of \(report.coveredDays)", "calendar", "Days with at least one press", nil)
+            }
+            GridRow {
+                card("Busiest day", report.records.busiestDay.map { $0.formatted(day) } ?? ClickyFormat.missing, "flame",
+                    report.records.busiestDay == nil ? "No presses yet" : "\(Int(report.records.busiestDayValue).formatted()) presses", nil)
+                card("Busiest hour", report.busiestHour.map { $0.formatted(.dateTime.month(.abbreviated).day().hour()) } ?? ClickyFormat.missing,
+                    "clock", report.busiestHour == nil ? "Hourly counts cover 1 year" : "\(report.busiestHourValue.formatted()) presses", nil)
+                card("Peak minute", report.peakMinuteValue.formatted(), "bolt",
+                    report.peakMinute.map { "At \($0.formatted(.dateTime.month(.abbreviated).day().hour().minute()))" } ?? "Minute detail covers 30 days", nil)
+            }
+            GridRow {
+                card("Current streak", "\(report.records.currentStreak) \(report.records.currentStreak == 1 ? "day" : "days")",
+                    "flame.fill", "Days in a row with typing", nil)
+                card("Longest streak", "\(report.records.longestStreak) \(report.records.longestStreak == 1 ? "day" : "days")",
+                    "trophy", "In this range", nil)
+                card("Today", todayPresses.formatted(), "sun.max", "Presses since midnight", nil)
+            }
+        }
+    }
+
+    private var rangeDetail: String {
+        switch range {
+        case ClickyRanges.today: return "Today so far"
+        case ClickyRanges.year: return "In the last year"
+        case ClickyRanges.all: return "In all kept data"
+        default: return "In the last \(range)"
+        }
+    }
+
+    private var todayPresses: Int {
+        let start = Int(Calendar.current.startOfDay(for: now).timeIntervalSince1970)
+        return data.days[start]?.presses ?? 0
+    }
+
+    private func card(_ title: String, _ value: String, _ symbol: String, _ detail: String, _ change: String?) -> some View {
         NativeSettingsCard {
             Label(title, systemImage: symbol).font(.caption).foregroundStyle(.secondary)
-            Text(value).font(.system(size: 26, weight: .semibold, design: .rounded)).monospacedDigit()
+            Text(value).font(.system(size: 22, weight: .semibold, design: .rounded)).monospacedDigit()
+                .lineLimit(1).minimumScaleFactor(0.7)
+            Text(detail).font(.caption).foregroundStyle(.secondary)
+            Text(change ?? " ").font(.caption).foregroundStyle(.secondary).accessibilityHidden(change == nil)
         }
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+        .accessibilityElement(children: .combine)
     }
 
     private var activity: some View {
-        NativeSettingsCard {
+        let resolutions = ClickyRanges.resolutions(for: interval, now: now)
+        return NativeSettingsCard {
             HStack {
                 Text("Activity timeline").font(.headline)
                 Spacer()
@@ -94,43 +230,51 @@ public struct ClickyAnalyticsView: View {
                     Text("Releases").tag(true)
                 }.labelsHidden().frame(width: 105, alignment: .trailing)
                 Picker("Time resolution", selection: $resolution) {
-                    ForEach(ClickyTimeResolution.allCases) { Text($0.rawValue).tag($0) }
+                    ForEach(resolutions) { Text($0.rawValue).tag($0) }
                 }.labelsHidden().frame(width: 110, alignment: .trailing)
                     .accessibilityIdentifier("clicky.stats.resolution")
             }
-            NativeTimeSeriesChart(points: data.timeline(resolution, releases: releases),
-                interval: resolution.seconds, initialWindow: resolution.initialWindow,
-                end: now, valueLabel: releases ? "Releases" : "Presses")
-                .id("\(resolution.rawValue).\(example != nil)")
-            Text("\(resolution.rawValue)-by-\(resolution.rawValue.lowercased()) recorded counts. Wide views combine nearby bins to keep scrolling responsive.")
-                .font(.caption2).foregroundStyle(.secondary)
+            NativeTimeSeriesChart(points: report.timeline, interval: resolution.seconds,
+                initialWindow: resolution.initialWindow, end: now, valueLabel: releases ? "Releases" : "Presses",
+                rangeStart: interval.start, style: $chartStyle)
+                .id("\(resolution.rawValue).\(range).\(example != nil)")
+            Text(resolutions == [.day]
+                ? "Hourly counts are kept for 1 year, so this range shows daily totals."
+                : resolutions.count < ClickyTimeResolution.allCases.count
+                    ? "Minute detail is kept for 30 days, so this range shows hours or days. Wide views combine nearby bars."
+                    : "\(resolution.rawValue)-by-\(resolution.rawValue.lowercased()) recorded counts. Wide views combine nearby bars.")
+                .font(.caption).foregroundStyle(.secondary)
         }
     }
 
     private var keys: some View {
         VStack(spacing: 18) {
-            NativeSettingsCard("Physical key heat map", subtitle: "Aggregate presses by key position · US labels · no text or sequence retained") {
+            NativeSettingsCard("Physical key heat map", subtitle: "Aggregate presses by key position since detailed statistics began. US labels; no text or sequence retained.") {
                 let peak = max(1, data.keys.values.max() ?? 0)
+                let total = max(1, data.keys.values.reduce(0, +))
                 VStack(spacing: 5) {
                     ForEach(ClickyKeyLayout.rows.indices, id: \.self) { row in
                         HStack(spacing: 4) {
                             ForEach(ClickyKeyLayout.rows[row]) { key in
                                 let count = data.keys[key.code, default: 0]
                                 Button { selectedKey = key.code } label: {
-                                    Text(key.label).font(.system(size: 10, weight: .medium))
+                                    Text(key.label).font(.system(size: 11, weight: .medium))
                                         .frame(maxWidth: .infinity).frame(height: 31)
                                         .background(.mint.opacity(count == 0 ? 0.05 : 0.12 + 0.65 * pow(Double(count) / Double(peak), 0.5)),
                                             in: RoundedRectangle(cornerRadius: 5))
                                         .overlay(RoundedRectangle(cornerRadius: 5).stroke(selectedKey == key.code ? .mint : .clear, lineWidth: 1))
-                                }.buttonStyle(.plain)
+                                        .contentShape(Rectangle())
+                                }.buttonStyle(.genHoverPlain())
                                     .help("\(key.label): \(count.formatted()) presses")
                                     .accessibilityLabel("\(key.label), \(count) presses")
+                                    .accessibilityAddTraits(selectedKey == key.code ? .isSelected : [])
                             }
                         }.padding(.horizontal, row == 3 ? 8 : row == 4 ? 15 : 0)
                     }
                 }
                 if let key = selectedKey {
-                    Text("\(ClickyKeyLayout.label(key)) · \(data.keys[key, default: 0].formatted()) presses")
+                    let count = data.keys[key, default: 0]
+                    Text("\(ClickyKeyLayout.label(key)): \(count.formatted()) presses, \(ClickyFormat.percent(Double(count) / Double(total))) of all")
                         .font(.caption).foregroundStyle(.mint)
                 } else { Text("Select a key to inspect its total.").font(.caption).foregroundStyle(.secondary) }
             }
@@ -144,23 +288,22 @@ public struct ClickyAnalyticsView: View {
     }
 
     private var rhythm: some View {
-        VStack(spacing: 18) {
-            NativeSettingsCard("When you type", subtitle: "Hour of day × day of week · local time · brighter means more recorded presses") {
-                NativeMatrixHeatmap(rows: ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
-                    columns: (0..<24).map { String(format: "%02d", $0) }, cells: data.weekdayHeatmap())
-                Text("Hover a cell for its count. Based on the retained year of hourly history.")
+        let order = ClickyWeekdays.order()
+        return VStack(spacing: 18) {
+            NativeSettingsCard("When you type", subtitle: "Hour of day by day of week in the selected range, local time. Brighter means more presses.") {
+                NativeMatrixHeatmap(rows: order.map { ClickyWeekdays.shortName($0) },
+                    columns: (0..<24).map { String(format: "%02d", $0) }, cells: report.heatmap)
+                Text("Hover a cell for its count. Hourly counts are kept for 1 year, so a longer range shows its last year here.")
                     .font(.caption).foregroundStyle(.secondary)
             }
             NativeSettingsCard("Day by day") {
-                NativeTimeSeriesChart(points: data.timeline(.day), interval: 86400,
-                    initialWindow: 7 * 86400, end: now, valueLabel: "Presses")
-                    .id("days.\(example != nil)")
+                NativeTimeSeriesChart(points: report.dayTimeline, interval: 86400,
+                    initialWindow: 7 * 86400, end: now, valueLabel: "Presses", rangeStart: interval.start, style: $chartStyle)
+                    .id("days.\(range).\(example != nil)")
             }
-            NativeSettingsCard("Weekday distribution") {
-                let cells = data.weekdayHeatmap()
-                let labels = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
-                NativeCategoryChart(values: labels.indices.map { row in
-                    NativeCategoryValue(label: labels[row], value: cells.filter { $0.row == row }.reduce(0) { $0 + $1.value })
+            NativeSettingsCard("Average day of the week", subtitle: "Presses per weekday, divided by how often that weekday occurs in the recorded range") {
+                NativeCategoryChart(values: order.map { weekday in
+                    NativeCategoryValue(label: ClickyWeekdays.name(weekday), value: report.weekdayAverages[weekday].rounded())
                 })
             }
         }
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAudio.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAudio.swift
index 70a0cd7b8c..02aa4aa0bf 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAudio.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyAudio.swift
@@ -28,11 +28,28 @@ public enum ClickySynthesis {
     }
 }
 
+/// A new click may cancel an idle stop, but cannot cancel a restart required by an output change.
+struct ClickyAudioStartState {
+    enum Completion: Equatable { case play, restart, stop }
+    private var stopRequested = false
+    private var restartRequired = false
+
+    mutating func requestClick() { stopRequested = false }
+    mutating func requestStop() { stopRequested = true }
+    mutating func outputChanged() { restartRequired = true }
+
+    mutating func complete() -> Completion {
+        let result: Completion = stopRequested ? .stop : restartRequired ? .restart : .play
+        restartRequired = false
+        return result
+    }
+}
+
 @MainActor
 final class ClickyAudio {
     private let engine: AVAudioEngine
     private let format = AVAudioFormat(standardFormatWithSampleRate: ClickySynthesis.sampleRate, channels: 1)!
-    private var voices: [(AVAudioPlayerNode, AVAudioUnitVarispeed)] = []
+    private let voices: [(AVAudioPlayerNode, AVAudioUnitVarispeed)]
     private var buffers: [String: AVAudioPCMBuffer] = [:]
     private var cursor = 0
     private var idleStop: DispatchWorkItem?
@@ -47,12 +64,53 @@ final class ClickyAudio {
     private var running = false
     /// The click that arrived while the engine starts; it plays once the engine runs (a newer one replaces it).
     private var pendingClick: (() -> Void)?
-    private var stopAfterStart = false
+    private var startState = ClickyAudioStartState()
     /// A hardware change stopped the engine while it was starting; the start then finished on a stopped engine.
     private var configChangedWhileStarting = false
+    /// The engine and its voices, used only on the start queue (or, rendering offline, on the caller's thread).
     private final class EngineBox: @unchecked Sendable {
         let engine: AVAudioEngine
-        init(_ engine: AVAudioEngine) { self.engine = engine }
+        let voices: [(AVAudioPlayerNode, AVAudioUnitVarispeed)]
+        let format: AVAudioFormat
+        private var wired = false
+        /// The output device the next start plays on; nil keeps the engine's own choice (the system output).
+        var device: AudioDeviceID?
+
+        init(engine: AVAudioEngine, voices: [(AVAudioPlayerNode, AVAudioUnitVarispeed)], format: AVAudioFormat) {
+            self.engine = engine
+            self.voices = voices
+            self.format = format
+        }
+
+        /// Wires the voices once, then starts. The first `mainMixerNode` read creates the output unit, which waits for
+        /// CoreAudio: 0.5 s on the main thread when the settings face launched (HangWatch, 2026-10-23 21:30).
+        func start() throws {
+            if let device, !AudioOutputs.pin(engine, to: device) {
+                PerfLog.mark("clicky.audio.output \(device) refused")
+            }
+            if !wired {
+                for (player, rate) in voices {
+                    engine.attach(player)
+                    engine.attach(rate)
+                    engine.connect(player, to: rate, format: format)
+                    engine.connect(rate, to: engine.mainMixerNode, format: format)
+                }
+                wired = true
+            }
+            try engine.start()
+        }
+    }
+    private let box: EngineBox
+    private var outputDevice: AudioDeviceID?
+
+    /// Plays on `device` from the next click on. A change stops the engine, so the next click starts it on the new device.
+    func setOutput(_ device: AudioDeviceID?) {
+        guard device != outputDevice else { return }
+        outputDevice = device
+        if starting { startState.outputChanged() }
+        let box = box
+        startQueue.async { box.device = device }
+        stopVoices()
     }
     private struct PackBank {
         let reference: ClickyPackReference
@@ -128,15 +186,9 @@ final class ClickyAudio {
 
     init(engine: AVAudioEngine = AVAudioEngine()) {
         self.engine = engine
-        for _ in 0..<12 {
-            let player = AVAudioPlayerNode()
-            let rate = AVAudioUnitVarispeed()
-            engine.attach(player)
-            engine.attach(rate)
-            engine.connect(player, to: rate, format: format)
-            engine.connect(rate, to: engine.mainMixerNode, format: format)
-            voices.append((player, rate))
-        }
+        let voices = (0..<12).map { _ in (AVAudioPlayerNode(), AVAudioUnitVarispeed()) }
+        self.voices = voices
+        box = EngineBox(engine: engine, voices: voices, format: format)
         for profile in ClickySwitch.allCases {
             for release in [false, true] {
                 for variant in 0..<3 {
@@ -150,7 +202,6 @@ final class ClickyAudio {
                 }
             }
         }
-        engine.prepare()
         // A hardware change stops the engine without telling `running`; the next click must start it again.
         NotificationCenter.default.addObserver(forName: .AVAudioEngineConfigurationChange, object: engine, queue: .main) { [weak self] _ in
             MainActor.assumeIsolated {
@@ -171,7 +222,7 @@ final class ClickyAudio {
         idleStop?.cancel()
         // Offline rendering (tests) starts at once: no hardware to wake.
         if !running, !starting, engine.isInManualRenderingMode {
-            try engine.start()
+            try box.start()
             running = true
         }
         guard running else {
@@ -186,32 +237,38 @@ final class ClickyAudio {
 
     private func startEngine() {
         // A click after a stop request cancels the stop, also while a start is already in flight.
-        stopAfterStart = false
+        startState.requestClick()
         guard !starting else { return }
         starting = true
-        let box = EngineBox(engine)
+        let box = box
         startQueue.async {
             let begun = Date()
             var failure: Error?
-            do { try box.engine.start() } catch { failure = error }
+            do { try box.start() } catch { failure = error }
             let ms = Date().timeIntervalSince(begun) * 1000
             DispatchQueue.main.async { [weak self] in
                 MainActor.assumeIsolated {
                     guard let self else { return }
                     self.starting = false
                     self.running = failure == nil
+                    let completion = self.startState.complete()
                     PerfLog.mark(String(format: "clicky.audio.start %.1fms off-main", ms)
                         + (failure.map { " failed: \($0.localizedDescription)" } ?? ""))
                     if self.configChangedWhileStarting {
                         // The engine stopped during the start: start it again before the waiting click plays.
                         self.configChangedWhileStarting = false
-                        if !self.stopAfterStart {
+                        if completion != .stop {
                             self.running = false
                             self.startEngine()
                             return
                         }
                     }
-                    if self.stopAfterStart {
+                    if completion == .restart {
+                        self.stopVoices()
+                        self.startEngine()
+                        return
+                    }
+                    if completion == .stop {
                         self.pendingClick = nil
                         self.stopVoices()
                         return
@@ -250,9 +307,11 @@ final class ClickyAudio {
         idleStop = nil
         // A start in flight finishes first; the engine stops right after it.
         if starting {
-            stopAfterStart = true
+            startState.requestStop()
             return
         }
+        // Never started: the voices are not wired yet, and a player outside an engine raises on stop.
+        guard running else { return }
         running = false
         for voice in voices { voice.0.stop() }
         engine.stop()
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyDelayPrompt.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyDelayPrompt.swift
new file mode 100644
index 0000000000..95b2e471b8
--- /dev/null
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyDelayPrompt.swift
@@ -0,0 +1,105 @@
+import AppKit
+import SwiftUI
+
+/// The prompt Clicky shows when its output is late (an AirPlay HomePod is about 2 s late): a small panel at the top
+/// right of the screen under the pointer. It never takes the keyboard (a non-activating panel ordered front without
+/// becoming key), and it closes by itself after `holdSeconds`.
+@MainActor
+final class ClickyDelayPrompt {
+    static let shared = ClickyDelayPrompt()
+
+    private var panel: NSPanel?
+    private var generation = 0
+
+    func show(late: AudioOutputDevice, suggestion: AudioOutputDevice, reduceMotion: Bool, holdSeconds: TimeInterval,
+              onSwitch: @escaping () -> Void, onKeep: @escaping () -> Void) {
+        generation += 1
+        let shown = generation
+        let view = ClickyDelayPromptView(
+            late: late, suggestion: suggestion,
+            onSwitch: { [weak self] in onSwitch(); self?.close(shown) },
+            onKeep: { [weak self] in onKeep(); self?.close(shown) },
+            onClose: { [weak self] in self?.close(shown) })
+        let host = NSHostingView(rootView: view)
+        let panel = self.panel ?? Self.makePanel()
+        self.panel = panel
+        panel.contentView = host
+        let size = host.fittingSize
+        let pointer = NSEvent.mouseLocation
+        let screen = (NSScreen.screens.first { $0.frame.contains(pointer) } ?? NSScreen.main)?.visibleFrame
+            ?? CGRect(x: 0, y: 0, width: 1440, height: 900)
+        panel.setFrame(CGRect(x: screen.maxX - size.width - 16, y: screen.maxY - size.height - 12,
+                              width: size.width, height: size.height), display: true)
+        panel.alphaValue = reduceMotion ? 1 : 0
+        panel.orderFrontRegardless()
+        if !reduceMotion {
+            NSAnimationContext.runAnimationGroup { context in
+                context.duration = 0.18
+                panel.animator().alphaValue = 1
+            }
+        }
+        if holdSeconds > 0 {
+            DispatchQueue.main.asyncAfter(deadline: .now() + holdSeconds) { [weak self] in
+                MainActor.assumeIsolated { self?.close(shown) }
+            }
+        }
+    }
+
+    private func close(_ shown: Int) {
+        guard shown == generation, let panel else { return }
+        panel.orderOut(nil)
+        panel.contentView = nil
+    }
+
+    private static func makePanel() -> NSPanel {
+        let panel = NSPanel(contentRect: .zero, styleMask: [.borderless, .nonactivatingPanel], backing: .buffered,
+                            defer: true)
+        panel.isOpaque = false
+        panel.backgroundColor = .clear
+        panel.hasShadow = true
+        panel.hidesOnDeactivate = false
+        panel.becomesKeyOnlyIfNeeded = true
+        panel.isReleasedWhenClosed = false
+        panel.level = .floating
+        panel.collectionBehavior = [.transient, .ignoresCycle, .fullScreenAuxiliary, .canJoinAllSpaces]
+        return panel
+    }
+}
+
+struct ClickyDelayPromptView: View {
+    let late: AudioOutputDevice
+    let suggestion: AudioOutputDevice
+    let onSwitch: () -> Void
+    let onKeep: () -> Void
+    let onClose: () -> Void
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 10) {
+            HStack(alignment: .firstTextBaseline, spacing: 8) {
+                Image(systemName: "speaker.wave.2.bubble.left.fill").foregroundStyle(.orange)
+                Text("Clicky sounds \(late.delayText) on \(late.name)")
+                    .font(.system(size: 13, weight: .semibold))
+                Spacer(minLength: 8)
+                IconButton(systemName: "xmark", tooltip: "Close; Clicky asks again after the next restart", action: onClose)
+            }
+            Text("Every key sound reaches you \(late.delayText). \(suggestion.name) is \(suggestion.delayText). Play Clicky there while the system plays on \(late.name)?")
+                .font(.system(size: 12)).foregroundStyle(.secondary)
+                .fixedSize(horizontal: false, vertical: true)
+            HStack {
+                Spacer()
+                Button("Keep \(late.name)", action: onKeep)
+                    .accessibilityIdentifier("clicky.delay.keep")
+                Button("Play there", action: onSwitch)
+                    .keyboardShortcut(.defaultAction)
+                    .accessibilityIdentifier("clicky.delay.switch")
+            }
+            .controlSize(.regular)
+        }
+        .padding(14)
+        .frame(width: 360)
+        .background(.regularMaterial, in: RoundedRectangle(cornerRadius: 12, style: .continuous))
+        .overlay(RoundedRectangle(cornerRadius: 12, style: .continuous).stroke(Color.primary.opacity(0.1)))
+        .accessibilityElement(children: .contain)
+        .accessibilityLabel("Clicky output is late")
+    }
+}
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyModel.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyModel.swift
index 1bcce74733..035b5d94d9 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyModel.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyModel.swift
@@ -54,6 +54,12 @@ public final class ClickyModel: ObservableObject {
     private var syncingAppearance = false
     private let log = Logger(subsystem: "dev.genesis.tools", category: "Clicky")
     private var audio: ClickyAudio?
+    /// The connected outputs and where Clicky plays, refreshed when the system output or the device list changes.
+    @Published public private(set) var outputs: [AudioOutputDevice] = []
+    @Published public private(set) var output: ClickyOutputResolution?
+    private var outputMonitor: AudioOutputMonitor?
+    /// Late outputs already offered an alternative in this run: the prompt shows once per output and launch.
+    private var delayPrompted: Set<String> = []
     private var previewGeneration = 0
     private let inputMonitor: any ClickyInputMonitoring
     private var observers: [NSObjectProtocol] = []
@@ -111,7 +117,7 @@ public final class ClickyModel: ObservableObject {
         }
         soundLibrary.install = { [weak self] reference, pack in
             guard let self else { throw ClickyPackError.invalid("Clicky is no longer available.") }
-            if self.audio == nil { self.audio = ClickyAudio() }
+            if self.audio == nil { self.makeAudio() }
             try self.audio?.install(reference: reference, pack: pack)
             self.previewGeneration &+= 1
             self.inputState.clear()
@@ -122,6 +128,8 @@ public final class ClickyModel: ObservableObject {
         }
         soundLibrary.restore(preferences.selectedPack)
         guard !previewOnly && observeSystemEvents else { return }
+        outputMonitor = AudioOutputMonitor { [weak self] in self?.refreshOutput() }
+        refreshOutput()
         let workspace = NSWorkspace.shared.notificationCenter
         for name in [
             NSWorkspace.didActivateApplicationNotification, NSWorkspace.willSleepNotification,
@@ -156,6 +164,28 @@ public final class ClickyModel: ObservableObject {
     }
 
     public var hasInputPermission: Bool { inputMonitor.hasPermission }
+
+    /// Whether key counts are recorded now, and if not, the first reason to fix.
+    public var recordingStatus: ClickyRecordingStatus {
+        if !preferences.collectStats { return .statisticsOff }
+        guard enabled else { return inputMonitor.hasPermission ? .clickyOff : .inputMonitoringMissing }
+        return ClickyRecordingStatus.pause(systemSleeping: systemSleeping,
+            takingBreak: sleepingUntil.map { $0 > Date() } ?? false,
+            quiet: preferences.isQuiet(at: Date()), excluded: excluded) ?? .recording
+    }
+
+    /// The fix the statistics pages offer for `recordingStatus`: turn statistics on, or turn Clicky on (which asks
+    /// for Input Monitoring through the permission dialog when it is missing).
+    public func fixRecording() {
+        switch recordingStatus {
+        case .recording: break
+        case .statisticsOff: preferences.collectStats = true
+        case .clickyOff, .inputMonitoringMissing: activate()
+        case .takingBreak: resume()
+        case .quietHours: preferences.quietHours = false
+        case .excludedApplication, .macSleeping: break
+        }
+    }
     public var isPaused: Bool {
         systemSleeping || preferences.isQuiet(at: Date()) || excluded || (sleepingUntil.map { $0 > Date() } ?? false)
     }
@@ -203,7 +233,7 @@ public final class ClickyModel: ObservableObject {
             return
         case .started: break
         }
-        if audio == nil { audio = ClickyAudio() }
+        if audio == nil { makeAudio() }
         enabled = true
         if !restoring { defaults.set(true, forKey: Self.enabledKey) }
         if preferences.collectStats && statisticsLoadError == nil {
@@ -212,6 +242,7 @@ public final class ClickyModel: ObservableObject {
             pendingStats = true
         }
         refreshContext()
+        offerFasterOutputIfLate()
         if !restoring { notify("Clicky enabled", body: "Your selected switch is \(selectedSoundName).") }
         log.notice("Input feedback activated\(restoring ? " (restored at launch)" : ""); no input content is retained")
     }
@@ -261,6 +292,8 @@ public final class ClickyModel: ObservableObject {
     }
 
     public func shutdown() {
+        outputMonitor?.stop()
+        outputMonitor = nil
         soundLibrary.stop()
         deactivate(remember: false)
         boundaryTimer?.invalidate()
@@ -446,9 +479,78 @@ public final class ClickyModel: ObservableObject {
             }
         }
         if let data = try? JSONEncoder().encode(preferences) { defaults.set(data, forKey: "clicky.preferences.v1") }
+        if previous.outputDeviceUID != preferences.outputDeviceUID || previous.outputRules != preferences.outputRules
+            || previous.delayWarning != preferences.delayWarning
+            || previous.delayWarningMilliseconds != preferences.delayWarningMilliseconds {
+            refreshOutput()
+        }
         refreshContext()
     }
 
+    // MARK: - Output
+
+    private func makeAudio() {
+        audio = ClickyAudio()
+        audio?.setOutput(output?.effective?.id)
+    }
+
+    /// Reads the outputs again, decides where Clicky plays, and offers a faster output when that one is late.
+    public func refreshOutput() {
+        outputs = AudioOutputs.outputs()
+        let resolved = ClickyOutputRouting.resolve(preferences: preferences, outputs: outputs,
+                                                   systemID: AudioOutputs.systemDefaultID())
+        if resolved != output, let effective = resolved.effective {
+            log.notice("Output \(effective.name, privacy: .public), \(effective.delayText, privacy: .public): \(resolved.reason, privacy: .public)")
+        }
+        output = resolved
+        audio?.setOutput(resolved.effective?.id)
+        offerFasterOutputIfLate()
+    }
+
+    private var delayLimit: TimeInterval { Double(preferences.delayWarningMilliseconds) / 1000 }
+
+    private func offerFasterOutputIfLate() {
+        guard enabled, !previewOnly, preferences.delayWarning, let late = output?.effective, late.delay > delayLimit,
+              !preferences.delayAcceptedUIDs.contains(late.uid), !delayPrompted.contains(late.uid),
+              let faster = AudioOutputs.suggestion(instead: late, outputs: outputs, limit: delayLimit)
+        else { return }
+        delayPrompted.insert(late.uid)
+        ClickyDelayPrompt.shared.show(
+            late: late, suggestion: faster, reduceMotion: appearance.reduceMotion,
+            holdSeconds: TimeInterval(preferences.delayPromptSeconds),
+            onSwitch: { [weak self] in self?.playLateOutputOn(faster) },
+            onKeep: { [weak self] in self?.preferences.delayAcceptedUIDs.append(late.uid) })
+    }
+
+    /// Replace an explicit pick, including a disconnected one; otherwise update the current system output's rule.
+    private func playLateOutputOn(_ faster: AudioOutputDevice) {
+        preferences = ClickyOutputRouting.acceptingFasterOutput(faster, preferences: preferences, resolution: output)
+    }
+
+    /// nil follows the system output.
+    public func pickOutput(_ device: AudioOutputDevice?) {
+        preferences.outputDeviceUID = device?.uid
+        preferences.outputDeviceName = device?.name
+    }
+
+    public func setRule(when system: AudioOutputDevice, playOn target: AudioOutputDevice) {
+        var rules = preferences.outputRules.filter { $0.whenUID != system.uid }
+        rules.append(ClickyOutputRule(whenUID: system.uid, whenName: system.name, playOnUID: target.uid,
+                                      playOnName: target.name))
+        preferences.outputRules = rules
+    }
+
+    public func removeRule(_ id: ClickyOutputRule.ID) {
+        preferences.outputRules.removeAll { $0.id == id }
+    }
+
+    /// Late outputs the user kept are offered an alternative again.
+    public func askAgainAboutLateOutputs() {
+        preferences.delayAcceptedUIDs = []
+        delayPrompted = []
+        offerFasterOutputIfLate()
+    }
+
     private func flushStatistics() {
         analytics.flush(statistics)
         guard statisticsLoadError == nil, pendingStats else { return }
@@ -576,7 +678,7 @@ public final class ClickyModel: ObservableObject {
     }
 
     private func playSelected(keyCode: UInt16, release: Bool, preview: Bool, pan: Float) {
-        if audio == nil { audio = ClickyAudio() }
+        if audio == nil { makeAudio() }
         do {
             let imported = try audio?.playSelected(keyCode: keyCode, release: release, preview: preview,
                                                    preferences: preferences, pan: pan) ?? false
@@ -594,7 +696,7 @@ public final class ClickyModel: ObservableObject {
     }
 
     private func play(profile: ClickySwitch, release: Bool, pan: Float) {
-        if audio == nil { audio = ClickyAudio() }
+        if audio == nil { makeAudio() }
         do {
             try audio?.play(profile: profile, release: release, preferences: preferences, pan: pan)
             if preferences.visualizer {
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyOutput.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyOutput.swift
new file mode 100644
index 0000000000..927293be18
--- /dev/null
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyOutput.swift
@@ -0,0 +1,72 @@
+import CoreAudio
+import Foundation
+
+/// "When the system plays on `whenUID`, Clicky plays on `playOnUID`." The names are kept for the settings list while a
+/// device is not connected.
+public struct ClickyOutputRule: Codable, Hashable, Identifiable, Sendable {
+    public var id = UUID()
+    public var whenUID: String
+    public var whenName: String
+    public var playOnUID: String
+    public var playOnName: String
+
+    public init(whenUID: String, whenName: String, playOnUID: String, playOnName: String) {
+        self.whenUID = whenUID
+        self.whenName = whenName
+        self.playOnUID = playOnUID
+        self.playOnName = playOnName
+    }
+}
+
+/// Where Clicky plays and why. `device` nil means the system output.
+public struct ClickyOutputResolution: Equatable, Sendable {
+    public let device: AudioOutputDevice?
+    public let system: AudioOutputDevice?
+    public let reason: String
+
+    /// The output the sound really comes out of.
+    public var effective: AudioOutputDevice? { device ?? system }
+}
+
+public enum ClickyOutputRouting {
+    static func acceptingFasterOutput(_ faster: AudioOutputDevice, preferences: ClickyPreferences,
+        resolution: ClickyOutputResolution?) -> ClickyPreferences {
+        var updated = preferences
+        if preferences.outputDeviceUID != nil {
+            updated.outputDeviceUID = faster.uid
+            updated.outputDeviceName = faster.name
+        } else if let system = resolution?.system {
+            updated.outputRules.removeAll { $0.whenUID == system.uid }
+            updated.outputRules.append(ClickyOutputRule(whenUID: system.uid, whenName: system.name,
+                playOnUID: faster.uid, playOnName: faster.name))
+        }
+        return updated
+    }
+
+    /// Which device Clicky plays on. A device picked by hand wins; otherwise the first rule for the current system output;
+    /// otherwise the system output. A picked or ruled device that is not connected falls back to the system output.
+    public static func resolve(preferences: ClickyPreferences, outputs: [AudioOutputDevice],
+                               systemID: AudioDeviceID?) -> ClickyOutputResolution {
+        let system = outputs.first { $0.id == systemID }
+        if let uid = preferences.outputDeviceUID {
+            if let picked = outputs.first(where: { $0.uid == uid }) {
+                return ClickyOutputResolution(device: picked, system: system, reason: "You picked \(picked.name).")
+            }
+            return ClickyOutputResolution(
+                device: nil, system: system,
+                reason: "\(preferences.outputDeviceName ?? "The picked output") is not connected, so Clicky plays on the system output.")
+        }
+        if let system, let rule = preferences.outputRules.first(where: { $0.whenUID == system.uid }) {
+            if let target = outputs.first(where: { $0.uid == rule.playOnUID }) {
+                return ClickyOutputResolution(
+                    device: target, system: system,
+                    reason: "A rule plays Clicky on \(target.name) while the system plays on \(system.name).")
+            }
+            return ClickyOutputResolution(
+                device: nil, system: system,
+                reason: "The rule for \(system.name) names \(rule.playOnName), which is not connected.")
+        }
+        return ClickyOutputResolution(device: nil, system: system, reason: "Clicky follows the system output.")
+    }
+
+}
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyOutputSettings.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyOutputSettings.swift
new file mode 100644
index 0000000000..9e5d92bebd
--- /dev/null
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyOutputSettings.swift
@@ -0,0 +1,126 @@
+import SwiftUI
+
+/// Clicky's "Output" card: the device it plays on, the rules per system output, and the late-output prompt.
+struct ClickyOutputCard: View {
+    @ObservedObject var model: ClickyModel
+
+    var body: some View {
+        NativeSettingsCard("Output", subtitle: nowPlaying) {
+            NativeSettingsPicker(
+                "Play Clicky on", detail: model.output?.reason, identifier: "clicky.output.device",
+                options: deviceOptions, selection: deviceSelection, width: 260)
+            if model.preferences.outputDeviceUID == nil {
+                Divider()
+                rules
+            }
+            Divider()
+            NativeSettingsToggle(
+                "Suggest a faster output",
+                detail: "When Clicky's output is late by more than the limit below, a small prompt offers a faster one. It never takes the keyboard.",
+                identifier: "clicky.output.delayWarning", isOn: $model.preferences.delayWarning)
+            if model.preferences.delayWarning {
+                NativeSettingsSegmented(
+                    "Late after", detail: "AirPlay speakers such as a HomePod are about 2 s late; built-in speakers about 30 ms.",
+                    identifier: "clicky.output.delayLimit",
+                    options: [100, 150, 300, 500].map { NativeSettingsOption($0, "\($0) ms") },
+                    selection: $model.preferences.delayWarningMilliseconds)
+                NativeSettingsPicker("Close prompt after", detail: "How long the faster-output suggestion stays visible.",
+                    identifier: "clicky.output.promptDuration",
+                    options: [NativeSettingsOption(15, "15 seconds"), NativeSettingsOption(45, "45 seconds"),
+                        NativeSettingsOption(120, "2 minutes"), NativeSettingsOption(0, "Until dismissed")],
+                    selection: $model.preferences.delayPromptSeconds)
+            }
+            if !model.preferences.delayAcceptedUIDs.isEmpty {
+                NativeSettingsRow("Kept although late", detail: keptNames) {
+                    Button("Ask again", action: model.askAgainAboutLateOutputs)
+                        .accessibilityIdentifier("clicky.output.askAgain")
+                }
+            }
+        }
+    }
+
+    private var nowPlaying: String? {
+        guard let effective = model.output?.effective else { return nil }
+        return "Now playing on \(effective.name), \(effective.delayText)."
+    }
+
+    private var deviceOptions: [NativeSettingsOption<String>] {
+        var options = [NativeSettingsOption("", "Same as the system output", detail: nil, symbol: "speaker.wave.2")]
+        options += model.outputs.filter { !$0.isVirtual || $0.uid == model.preferences.outputDeviceUID }.map {
+            NativeSettingsOption($0.uid, "\($0.name) (\($0.delayText))")
+        }
+        if let uid = model.preferences.outputDeviceUID, !model.outputs.contains(where: { $0.uid == uid }) {
+            options.append(NativeSettingsOption(uid, "\(model.preferences.outputDeviceName ?? "Output") (not connected)"))
+        }
+        return options
+    }
+
+    private var deviceSelection: Binding<String> {
+        Binding(
+            get: { model.preferences.outputDeviceUID ?? "" },
+            set: { uid in
+                if uid.isEmpty {
+                    model.pickOutput(nil)
+                } else if let device = model.outputs.first(where: { $0.uid == uid }) {
+                    model.pickOutput(device)
+                }
+            })
+    }
+
+    private var keptNames: String {
+        model.preferences.delayAcceptedUIDs.map { uid in model.outputs.first { $0.uid == uid }?.name ?? "A disconnected output" }
+            .joined(separator: ", ")
+    }
+
+    @ViewBuilder private var rules: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text("Rules").font(.system(size: 12, weight: .semibold))
+            Text("While the system plays on one output, Clicky can play on another one.")
+                .font(.system(size: 11)).foregroundStyle(.secondary)
+            ForEach(model.preferences.outputRules) { rule in
+                ClickyOutputRuleRow(model: model, rule: rule)
+            }
+            if let system = model.output?.system, !model.preferences.outputRules.contains(where: { $0.whenUID == system.uid }) {
+                Button("Add a rule for \(system.name)") {
+                    let target = AudioOutputs.suggestion(instead: system, outputs: model.outputs, limit: .infinity)
+                    model.setRule(when: system, playOn: target ?? system)
+                }
+                .accessibilityIdentifier("clicky.output.addRule")
+            }
+        }
+    }
+}
+
+private struct ClickyOutputRuleRow: View {
+    @ObservedObject var model: ClickyModel
+    let rule: ClickyOutputRule
+
+    var body: some View {
+        HStack(spacing: 8) {
+            Text("When the system plays on \(rule.whenName), play on").font(.system(size: 12))
+            Picker("Play on", selection: target) {
+                ForEach(model.outputs.filter { !$0.isVirtual }) { device in
+                    Text("\(device.name) (\(device.delayText))").tag(device.uid)
+                }
+                if !model.outputs.contains(where: { $0.uid == rule.playOnUID }) {
+                    Text("\(rule.playOnName) (not connected)").tag(rule.playOnUID)
+                }
+            }
+            .labelsHidden().fixedSize()
+            Spacer(minLength: 0)
+            IconButton(systemName: "trash", tooltip: "Remove this rule") { model.removeRule(rule.id) }
+        }
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("clicky.output.rule.\(rule.whenUID)")
+    }
+
+    private var target: Binding<String> {
+        Binding(
+            get: { rule.playOnUID },
+            set: { uid in
+                guard let device = model.outputs.first(where: { $0.uid == uid }) else { return }
+                let system = AudioOutputDevice(id: 0, uid: rule.whenUID, name: rule.whenName, transport: 0, delay: 0)
+                model.setRule(when: system, playOn: device)
+            })
+    }
+}
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformance.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformance.swift
index 0e667c4523..6ef2e4dc5a 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformance.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformance.swift
@@ -16,14 +16,36 @@ public struct ClickyPerformanceBucket: Codable, Equatable, Sendable {
     public var activeSeconds = 0.0
     public var bursts = 0
     public var carriedBurst = false
+    /// Typing sessions that start in this bucket: text after a minute or more without text.
+    public var sessions = 0
+    /// Frozen at the retention boundary before the preceding minute is discarded. Nil derives it from neighbours.
+    var startsTypingSession: Bool?
     public init() {}
 
+    private enum CodingKeys: String, CodingKey {
+        case presses, characters, corrections, activeSeconds, bursts, carriedBurst, sessions, startsTypingSession
+    }
+
+    /// Every key is optional, so buckets saved before `sessions` existed still load.
+    public init(from decoder: Decoder) throws {
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        presses = try values.decodeIfPresent(Int.self, forKey: .presses) ?? 0
+        characters = try values.decodeIfPresent(Int.self, forKey: .characters) ?? 0
+        corrections = try values.decodeIfPresent(Int.self, forKey: .corrections) ?? 0
+        activeSeconds = try values.decodeIfPresent(Double.self, forKey: .activeSeconds) ?? 0
+        bursts = try values.decodeIfPresent(Int.self, forKey: .bursts) ?? 0
+        carriedBurst = try values.decodeIfPresent(Bool.self, forKey: .carriedBurst) ?? false
+        sessions = try values.decodeIfPresent(Int.self, forKey: .sessions) ?? 0
+        startsTypingSession = try values.decodeIfPresent(Bool.self, forKey: .startsTypingSession)
+    }
+
     mutating func add(_ other: Self) {
         presses += other.presses
         characters += other.characters
         corrections += other.corrections
         activeSeconds += other.activeSeconds
         bursts += other.bursts
+        sessions += other.sessions
     }
     var estimatedWords: Double { Double(characters) / 5 }
     var estimatedRetainedWords: Double { Double(max(0, characters - corrections)) / 5 }
@@ -42,6 +64,37 @@ extension ClickyStatistics {
 
     public mutating func breakTypingBurst() { lastTypingAt = nil }
 
+    /// Minute detail is kept for this long; older minutes are rolled into `performanceHours`.
+    static let performanceMinuteDays = 30
+    /// The hourly roll-up is kept for this long.
+    static let performanceHourDays = 730
+
+    /// Whether `minute` starts a typing session: it has text and the minute before it has none.
+    static func startsSession(_ minute: Int, in minutes: [Int: ClickyPerformanceBucket]) -> Bool {
+        minutes[minute]?.startsTypingSession
+            ?? ((minutes[minute]?.characters ?? 0) > 0 && (minutes[minute - 1]?.characters ?? 0) == 0)
+    }
+
+    /// Rolls the minutes older than `horizon` into hourly buckets, then drops them and hours past their retention.
+    mutating func rollUpPerformance(olderThan horizon: Int) {
+        let old = performanceMinutes.filter { $0.key < horizon }
+        // Freeze the first retained minute while its predecessor is still available, including across saves.
+        if performanceMinutes[horizon] != nil {
+            let starts = Self.startsSession(horizon, in: performanceMinutes)
+            performanceMinutes[horizon]?.startsTypingSession = starts
+        }
+        for (minute, source) in old {
+            var bucket = source
+            bucket.carriedBurst = false
+            bucket.sessions = Self.startsSession(minute, in: performanceMinutes) ? 1 : 0
+            performanceHours[Int(floor(Double(minute) / 60)), default: ClickyPerformanceBucket()].add(bucket)
+        }
+        performanceMinutes = performanceMinutes.filter { $0.key >= horizon }
+        let recordingMinute = horizon + Self.performanceMinuteDays * 24 * 60
+        let oldestHour = recordingMinute / 60 - Self.performanceHourDays * 24
+        performanceHours = performanceHours.filter { $0.key >= oldestHour }
+    }
+
     mutating func recordPerformance(keyCode: UInt16, shortcut: Bool, at date: Date) {
         let minute = Int(floor(date.timeIntervalSince1970 / 60))
         performanceMinutes[minute, default: ClickyPerformanceBucket()].presses += 1
@@ -100,7 +153,7 @@ struct ClickyPerformanceFilter: Equatable, Sendable {
 }
 
 enum ClickyPerformanceGrouping: Int, CaseIterable, Identifiable, Sendable {
-    case minute = 60, fiveMinutes = 300, fifteenMinutes = 900, hour = 3600, day = 86400
+    case minute = 60, fiveMinutes = 300, fifteenMinutes = 900, hour = 3600, day = 86400, week = 604800
     var id: Self { self }
     var label: String {
         switch self {
@@ -109,6 +162,7 @@ enum ClickyPerformanceGrouping: Int, CaseIterable, Identifiable, Sendable {
         case .fifteenMinutes: return "15 minutes"
         case .hour: return "Hour"
         case .day: return "Day"
+        case .week: return "Week"
         }
     }
 }
@@ -124,9 +178,14 @@ struct ClickyPerformanceReport: Sendable {
     var timeline: [ClickyPerformancePoint] = []
     var hours = Array(repeating: ClickyPerformanceBucket(), count: 24)
     var weekdays = Array(repeating: ClickyPerformanceBucket(), count: 7)
+    /// Totals per local calendar day, for active days, records and per-day averages.
+    var days: [Date: ClickyPerformanceBucket] = [:]
 
     init() {}
 
+    /// Days with any timed typing.
+    var activeDays: Int { days.values.filter { $0.activeSeconds > 0 || $0.characters > 0 }.count }
+
     /// `beforeBuild` runs on the worker before the report is built; tests use it to cancel while the worker runs.
     static func prepare(statistics: ClickyStatistics, filter: ClickyPerformanceFilter,
         grouping: ClickyPerformanceGrouping, calendar: Calendar = .current,
@@ -149,8 +208,14 @@ struct ClickyPerformanceReport: Sendable {
     init(statistics: ClickyStatistics, filter: ClickyPerformanceFilter,
         grouping: ClickyPerformanceGrouping, calendar: Calendar = .current) {
         var groups: [Date: ClickyPerformanceBucket] = [:]
-        for (minute, source) in statistics.performanceMinutes {
-            let date = Date(timeIntervalSince1970: Double(minute) * 60)
+        let minuteBuckets = statistics.performanceMinutes.map { minute, source -> (Date, ClickyPerformanceBucket) in
+            var bucket = source
+            bucket.sessions = ClickyStatistics.startsSession(minute, in: statistics.performanceMinutes) ? 1 : 0
+            return (Date(timeIntervalSince1970: Double(minute) * 60), bucket)
+        }
+        // Rolled-up hours hold only minutes that are no longer kept, so the two never count the same press twice.
+        let hourBuckets = statistics.performanceHours.map { (Date(timeIntervalSince1970: Double($0.key) * 3600), $0.value) }
+        for (date, source) in minuteBuckets + hourBuckets {
             guard filter.includes(date, calendar: calendar) else { continue }
             var bucket = source
             if bucket.carriedBurst && !filter.includes(date.addingTimeInterval(-60), calendar: calendar) {
@@ -159,7 +224,10 @@ struct ClickyPerformanceReport: Sendable {
             total.add(bucket)
             hours[calendar.component(.hour, from: date)].add(bucket)
             weekdays[(calendar.component(.weekday, from: date) + 5) % 7].add(bucket)
-            let key = grouping == .day ? calendar.startOfDay(for: date)
+            let day = calendar.startOfDay(for: date)
+            days[day, default: ClickyPerformanceBucket()].add(bucket)
+            let key = grouping == .week ? (calendar.dateInterval(of: .weekOfYear, for: date)?.start ?? day)
+                : grouping == .day ? day
                 : Date(timeIntervalSince1970: floor(date.timeIntervalSince1970 / Double(grouping.rawValue)) * Double(grouping.rawValue))
             groups[key, default: ClickyPerformanceBucket()].add(bucket)
         }
@@ -171,12 +239,25 @@ struct ClickyDictationEstimate {
     let typingSeconds: Double
     let speakingSeconds: Double
     let setupSeconds: Double
-    var dictationSeconds: Double { speakingSeconds + setupSeconds }
+    let reviewSeconds: Double
+    let retainedWords: Double
+    var dictationSeconds: Double { speakingSeconds + setupSeconds + reviewSeconds }
     var differenceSeconds: Double { typingSeconds - dictationSeconds }
 
-    init(totals: ClickyPerformanceBucket, wordsPerMinute: Int, setupPerBurst: Int) {
-        typingSeconds = totals.activeSeconds
-        speakingSeconds = totals.estimatedRetainedWords * 60 / Double(max(1, wordsPerMinute))
-        setupSeconds = Double(totals.bursts * max(0, setupPerBurst))
+    /// One dictation covers a whole typing session, so its setup counts once per session, not per 5-second burst:
+    /// with setup per burst, 8,042 bursts in a week cost 6.7 h of setup and the estimate said dictation saved nothing
+    /// (Martin's data, 2026-10-25: 718 sessions in the same week).
+    ///
+    /// `dictatedShare` (0...1) is the part of the typing the user would dictate at all: code, commands and passwords
+    /// stay typed, and Clicky cannot tell them apart without reading text. It scales both sides and the sessions
+    /// alike. `reviewShare` adds reading and fixing the transcript, as a share of the speaking time.
+    init(totals: ClickyPerformanceBucket, wordsPerMinute: Int, setupPerSession: Int,
+        dictatedShare: Double = 1, reviewShare: Double = 0) {
+        let share = min(1, max(0, dictatedShare))
+        retainedWords = totals.estimatedRetainedWords * share
+        typingSeconds = totals.activeSeconds * share
+        speakingSeconds = retainedWords * 60 / Double(max(1, wordsPerMinute))
+        setupSeconds = Double(totals.sessions * max(0, setupPerSession)) * share
+        reviewSeconds = speakingSeconds * max(0, reviewShare)
     }
 }
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformanceView.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformanceView.swift
index f0c94e85f9..4eab43acb0 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformanceView.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyPerformanceView.swift
@@ -4,46 +4,109 @@ import SwiftUI
 @MainActor
 public struct ClickyPerformanceView: View {
     @ObservedObject private var store: ClickyAnalyticsStore
-    @State private var range = "7 days"
-    @State private var start = Calendar.current.startOfDay(for: Date())
-    @State private var end = Date()
-    @State private var grouping: ClickyPerformanceGrouping = .fifteenMinutes
+    private let status: ClickyRecordingStatus
+    private let fixRecording: (() -> Void)?
+    @AppStorage private var storedRange: String
+    @AppStorage private var startTimestamp: Double
+    @AppStorage private var endTimestamp: Double
+    var start: Date {
+        get { Date(timeIntervalSince1970: startTimestamp) }
+        nonmutating set { startTimestamp = newValue.timeIntervalSince1970 }
+    }
+    var end: Date {
+        get { Date(timeIntervalSince1970: endTimestamp) }
+        nonmutating set { endTimestamp = newValue.timeIntervalSince1970 }
+    }
+    @State private var requestedGrouping: ClickyPerformanceGrouping
+    private var grouping: ClickyPerformanceGrouping {
+        ClickyRanges.validGrouping(requestedGrouping, for: interval, now: now)
+    }
     @State private var weekdays = Set(0..<7)
     @State private var fromHour = 0
     @State private var untilHour = 24
-    @State private var metric = "Presses"
-    @State private var comparison = "Time of day"
+    @AppStorage private var storedMetric: String
+    @AppStorage private var comparison: String
+    @AppStorage private var chartStyle: NativeTimeSeriesChart.Style
+    @AppStorage private var showFun: Bool
     @State private var example: ClickyStatistics?
     @State private var exampleTime: Date?
     @State private var preparedReport = ClickyPerformanceReport()
+    @State private var previousReport: ClickyPerformanceReport?
+    @State private var loaded = false
     @State private var preparing = false
+    @State private var refresh = 0
+    @State private var refreshPending = false
+    @State private var lastUserQuery: Query?
     @AppStorage private var spokenWPM: Int
     @AppStorage private var setupSeconds: Int
-    private let weekdayNames = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+    @AppStorage private var dictatedPercent: Int
+    @AppStorage private var reviewPercent: Int
 
-    public init(store: ClickyAnalyticsStore, defaults: UserDefaults) {
+    /// - Parameters:
+    ///   - status: whether Clicky records right now; anything but `.recording` shows why under the title.
+    ///   - fixRecording: the action of the button beside that reason.
+    public init(store: ClickyAnalyticsStore, defaults: UserDefaults, status: ClickyRecordingStatus = .recording,
+        fixRecording: (() -> Void)? = nil) {
         self.store = store
+        self.status = status
+        self.fixRecording = fixRecording
+        let range = ClickyRanges.known(defaults.string(forKey: "clicky.performance.range") ?? ClickyRanges.week,
+            allowed: Self.ranges)
+        _storedRange = AppStorage(wrappedValue: ClickyRanges.week, "clicky.performance.range", store: defaults)
+        let reference = Date()
+        let defaultStart = Calendar.current.startOfDay(for: reference).timeIntervalSince1970
+        _startTimestamp = AppStorage(wrappedValue: defaultStart, "clicky.performance.customStart", store: defaults)
+        _endTimestamp = AppStorage(wrappedValue: reference.timeIntervalSince1970, "clicky.performance.customEnd", store: defaults)
+        let restored = ClickyRanges.interval(range, now: reference, earliest: nil,
+            customStart: Date(timeIntervalSince1970: defaults.object(forKey: "clicky.performance.customStart") as? Double ?? defaultStart),
+            customEnd: Date(timeIntervalSince1970: defaults.object(forKey: "clicky.performance.customEnd") as? Double ?? reference.timeIntervalSince1970))
+        _requestedGrouping = State(initialValue: ClickyRanges.grouping(for: range, span: restored.duration))
+        _storedMetric = AppStorage(wrappedValue: Metric.presses.rawValue, "clicky.performance.metric", store: defaults)
+        _comparison = AppStorage(wrappedValue: "Time of day", "clicky.performance.comparison", store: defaults)
+        _chartStyle = AppStorage(wrappedValue: .area, "clicky.performance.chartStyle", store: defaults)
+        _showFun = AppStorage(wrappedValue: true, "clicky.performance.showFun", store: defaults)
         _spokenWPM = AppStorage(wrappedValue: 140, "clicky.performance.spokenWPM", store: defaults)
         _setupSeconds = AppStorage(wrappedValue: 3, "clicky.performance.setupSeconds", store: defaults)
+        _dictatedPercent = AppStorage(wrappedValue: 70, "clicky.performance.dictatedPercent", store: defaults)
+        _reviewPercent = AppStorage(wrappedValue: 15, "clicky.performance.reviewPercent", store: defaults)
     }
+
+    enum Metric: String, CaseIterable {
+        case presses = "Presses", words = "Words typed", time = "Typing time", pace = "Pace"
+        case corrections = "Correction share", sessions = "Typing sessions"
+    }
+
+    private var range: String { ClickyRanges.known(storedRange, allowed: Self.ranges) }
+    private var metric: Metric { Metric(rawValue: storedMetric) ?? .presses }
     private var data: ClickyStatistics { example ?? store.snapshot }
     private var now: Date { exampleTime ?? Date() }
+    private var interval: DateInterval {
+        ClickyRanges.interval(range, now: now, earliest: earliest, customStart: start, customEnd: end)
+    }
     private var filter: ClickyPerformanceFilter {
-        let calendar = Calendar.current
-        let first: Date
-        switch range {
-        case "Today": first = calendar.startOfDay(for: now)
-        case "30 days": first = calendar.date(byAdding: .day, value: -29, to: calendar.startOfDay(for: now)) ?? now
-        case "Custom": first = calendar.startOfDay(for: start)
-        default: first = calendar.date(byAdding: .day, value: -6, to: calendar.startOfDay(for: now)) ?? now
-        }
-        let last = range == "Custom"
-            ? calendar.date(byAdding: .day, value: 1, to: calendar.startOfDay(for: end)) ?? now : now
-        return ClickyPerformanceFilter(start: first, end: last, weekdays: weekdays, fromHour: fromHour, untilHour: untilHour)
+        ClickyPerformanceFilter(start: interval.start, end: interval.end, weekdays: weekdays, fromHour: fromHour,
+            untilHour: untilHour)
+    }
+    private var previousFilter: ClickyPerformanceFilter? {
+        guard let previous = ClickyRanges.previous(interval, range: range), earliest < previous.end else { return nil }
+        var shifted = filter
+        shifted.start = previous.start
+        shifted.end = previous.end
+        return shifted
+    }
+    private var previousName: String { ClickyRanges.previousName(interval, range: range) }
+    private var filtered: Bool { weekdays.count < 7 || fromHour != 0 || untilHour != 24 }
+
+    private var earliest: Date { ClickyRetention.performanceStart(data, now: now) ?? now }
+
+    nonisolated static let ranges = ClickyRanges.presets + [ClickyRanges.custom]
+
+    /// The timeline grouping a range opens with: about 50 to 400 bars, never one bar per minute over a year.
+    nonisolated static func grouping(for range: String) -> ClickyPerformanceGrouping {
+        ClickyRanges.grouping(for: range)
     }
 
     private struct Query: Equatable {
-        let revision: UInt64
         let range: String
         let start: Date
         let end: Date
@@ -52,224 +115,510 @@ public struct ClickyPerformanceView: View {
         let fromHour: Int
         let untilHour: Int
         let exampleTime: Date?
+        var refresh: Int
     }
     private var query: Query {
-        Query(revision: example == nil ? store.revision : 0, range: range, start: start, end: end,
-            grouping: grouping, weekdays: weekdays, fromHour: fromHour, untilHour: untilHour, exampleTime: exampleTime)
+        Query(range: range, start: start, end: end, grouping: grouping, weekdays: weekdays, fromHour: fromHour,
+            untilHour: untilHour, exampleTime: exampleTime, refresh: refresh)
+    }
+
+    /// A range that ends now gets new data while the user types; a closed one never changes.
+    private var live: Bool { example == nil && interval.end >= Date().addingTimeInterval(-60) }
+
+    /// New key presses rebuild the report at most every 5 seconds, not on every published second.
+    private func scheduleRefresh() {
+        guard live, !refreshPending else { return }
+        refreshPending = true
+        Task { @MainActor in
+            try? await Task.sleep(for: .seconds(5))
+            refreshPending = false
+            refresh &+= 1
+        }
     }
 
     public var body: some View {
         let report = preparedReport
         VStack(alignment: .leading, spacing: 18) {
-            HStack {
-                VStack(alignment: .leading, spacing: 4) {
-                    Text("Find your typing rhythm").font(.system(size: 21, weight: .semibold, design: .rounded))
-                    Text(example == nil ? "Local aggregates · pauses over 5 seconds stop the clock" : "Sample performance · never saved")
-                        .font(.caption).foregroundStyle(example == nil ? Color.secondary : .orange)
-                }
-                Spacer()
-                if preparing { ProgressView().controlSize(.small).help("Preparing the selected time range") }
-                Button(example == nil ? "Explore sample data" : "Back to my data") {
-                    if example == nil {
-                        let reference = Date()
-                        exampleTime = reference
-                        example = ClickyStatistics.example(now: reference)
-                    } else { example = nil; exampleTime = nil }
-                }.buttonStyle(.bordered).accessibilityIdentifier("clicky.performance.example")
+            header
+            if example == nil, let message = status.message {
+                ClickyRecordingBanner(message: message, actionTitle: status.actionTitle, action: fixRecording)
             }
-            filters
-            if range == "Custom" && end < start {
-                Label("Choose an end date on or after the start date.", systemImage: "calendar.badge.exclamationmark")
-                    .foregroundStyle(.orange)
-            }
-            if data.performanceStartedAt == nil {
+            if data.performanceStartedAt == nil && example == nil {
                 NativeSettingsCard {
-                    Label("Timing starts with your next recorded key press.", systemImage: "stopwatch")
-                    Text("Earlier totals do not contain pauses or active seconds. Clicky keeps those totals without inventing performance history.")
-                        .font(.caption).foregroundStyle(.secondary)
+                    EmptyState(symbol: "stopwatch",
+                        text: status == .recording ? "Timing starts with your next recorded key press."
+                            : "No timing history yet.",
+                        detail: "Earlier totals do not contain pauses or typing time, so Clicky keeps them without inventing performance history.",
+                        actionTitle: "Explore Sample Data", action: showExample)
                 }
-            }
-            HStack(spacing: 12) {
-                number("Presses", report.total.presses.formatted(), "keyboard", "All recorded key-down events")
-                number("Estimated words", report.total.estimatedWords.formatted(.number.precision(.fractionLength(1))), "text.word.spacing", "5 text-like presses per word")
-                number("Active typing", duration(report.total.activeSeconds), "stopwatch", "Long pauses excluded")
-            }
-            timeline(report)
-            dictation(report.total)
-            HStack(spacing: 12) {
-                number("Estimated pace", report.total.wordsPerMinute.map { String(format: "%.1f WPM", $0) } ?? "—",
-                    "speedometer", "Weighted by active time")
-                number("Correction share", report.total.correctionShare.formatted(.percent.precision(.fractionLength(1))),
-                    "delete.left", "Delete presses / text + delete")
-                number("Average burst", report.total.bursts > 0 ? duration(report.total.activeSeconds / Double(report.total.bursts)) : "—",
-                    "waveform.path", "Active seconds / started bursts")
-            }
-            pace(report)
-            playful(report.total)
-            NativeSettingsCard("How the estimates work") {
-                Text("Only intervals between text-like key presses of 5 seconds or less count as active typing. Longer gaps add no time; isolated presses have no measurable duration. Key releases, modifiers and Command/Control shortcuts add no words. Navigation and shortcuts end a typing burst.")
-                Text("Words are a keystroke convention, not captured text. Code, pasted text, autocomplete, non-Latin input and editing can change the result. Correction share counts delete keys; it is not an error-rate score. No text, key sequence or application history is retained.")
-                Text("Performance retains 30 days of minute aggregates. Filters use your current local calendar; rates divide combined words by combined active seconds, rather than averaging bucket speeds. Date and hour filters have minute precision.")
-                if let since = data.performanceStartedAt {
-                    Text("Timing history since \(since.formatted(date: .abbreviated, time: .shortened))")
+            } else {
+                filters
+                if range == ClickyRanges.custom && end < start {
+                    Label("Choose an end date on or after the start date.", systemImage: "calendar.badge.exclamationmark")
+                        .foregroundStyle(.orange)
                 }
-            }.font(.caption).foregroundStyle(.secondary)
+                if loaded && report.total.presses == 0 { emptyResult }
+                numbers(report)
+                    .redacted(reason: loaded ? [] : .placeholder)
+                    .opacity(preparing ? 0.55 : 1)
+                timeline(report)
+                dictation(report)
+                pace(report)
+                records(report)
+                if showFun { playful(report.total) }
+                NativeSettingsCard("How the estimates work") {
+                    Text("Only intervals between text-like key presses of 5 seconds or less count as typing time. Longer gaps add no time; isolated presses have no measurable duration. Key releases, modifiers and Command or Control shortcuts add no words. Navigation and shortcuts end a typing burst.")
+                    Text("Words are a keystroke convention, not captured text: 5 text-like presses make one word typed. Words kept subtract the delete presses. Code, pasted text, autocomplete, non-Latin input and editing can change the result. Correction share counts delete keys; it is not an error-rate score. No text, key sequence or application history is retained.")
+                    Text("A typing session starts at a clock minute with text after a clock minute without text, so the session count is approximate. Filters use your current local calendar; rates divide combined words by combined typing time, rather than averaging bucket speeds. Ranges past 30 days count whole hours.")
+                    Text(ClickyRetention.text)
+                    if let since = data.performanceStartedAt {
+                        Text("Timing history since \(since.formatted(date: .abbreviated, time: .shortened)).")
+                    }
+                    Toggle("Show the just-for-fun cards", isOn: $showFun).toggleStyle(.checkbox)
+                        .accessibilityIdentifier("clicky.performance.showFun")
+                }.font(.caption).foregroundStyle(.secondary)
+            }
         }
         .onAppear { store.attach() }
         .onDisappear { store.detach() }
+        .onChange(of: store.revision) { _, _ in scheduleRefresh() }
+        .onChange(of: start) { _, _ in if range == ClickyRanges.custom { regroupCustom() } }
+        .onChange(of: end) { _, _ in if range == ClickyRanges.custom { regroupCustom() } }
         .task(id: query) {
-            preparing = true
-            let result = await ClickyPerformanceReport.prepare(statistics: data, filter: filter, grouping: grouping)
+            var userQuery = query
+            userQuery.refresh = 0
+            // A refresh while typing updates in place; only a change the user made shows progress, and only when it
+            // takes longer than 300 ms.
+            let quiet = userQuery == lastUserQuery
+            lastUserQuery = userQuery
+            let spinner = Task { @MainActor in
+                try? await Task.sleep(for: .milliseconds(300))
+                if !Task.isCancelled && !quiet { preparing = true }
+            }
+            defer { spinner.cancel() }
+            let statistics = data
+            let previousFilter = previousFilter
+            async let current = ClickyPerformanceReport.prepare(statistics: statistics, filter: filter, grouping: grouping)
+            async let earlier: ClickyPerformanceReport? = previousFilter == nil ? nil
+                : ClickyPerformanceReport.prepare(statistics: statistics, filter: previousFilter!, grouping: .day)
+            let (result, previous) = await (current, earlier)
             guard !Task.isCancelled else { return }
-            if let result { preparedReport = result }
+            if let result {
+                preparedReport = result
+                previousReport = previous
+                loaded = true
+            }
             preparing = false
         }
     }
 
+    private func showExample() {
+        let reference = Date()
+        exampleTime = reference
+        example = ClickyStatistics.example(now: reference)
+        AccessibilityNotification.Announcement("Showing sample data. It is never saved.").post()
+    }
+
+    private func regroupCustom() {
+        requestedGrouping = ClickyRanges.grouping(for: ClickyRanges.custom, span: interval.duration)
+    }
+
+    private var header: some View {
+        HStack {
+            VStack(alignment: .leading, spacing: 4) {
+                Text("Find your typing rhythm").font(.system(size: 21, weight: .semibold, design: .rounded))
+                Text(example == nil ? "Local aggregates. Pauses over 5 seconds stop the clock." : "Sample performance, never saved")
+                    .font(.caption).foregroundStyle(example == nil ? Color.secondary : .orange)
+            }
+            Spacer()
+            if preparing { ProgressView().controlSize(.small).help("Preparing the selected time range") }
+            Button(example == nil ? "Explore Sample Data" : "Back to My Data") {
+                if example == nil { showExample() } else {
+                    example = nil
+                    exampleTime = nil
+                    AccessibilityNotification.Announcement("Showing your data.").post()
+                }
+            }.buttonStyle(.bordered).accessibilityIdentifier("clicky.performance.example")
+        }
+    }
+
     private var filters: some View {
         NativeSettingsCard("Time and filters") {
             NativeSettingsRow("Date range") {
-                Picker("Date range", selection: $range) {
-                    ForEach(["Today", "7 days", "30 days", "Custom"], id: \.self) { Text($0).tag($0) }
+                Picker("Date range", selection: Binding(get: { range }, set: { storedRange = $0 })) {
+                    ForEach(Self.ranges, id: \.self) { Text($0).tag($0) }
                 }.labelsHidden().frame(width: 150, alignment: .trailing)
                     .accessibilityIdentifier("clicky.performance.range")
+                    .onChange(of: storedRange) { _, next in
+                        requestedGrouping = next == ClickyRanges.custom
+                            ? ClickyRanges.grouping(for: next, span: interval.duration) : Self.grouping(for: next)
+                    }
             }
-            if range == "Custom" {
+            if let coverage = ClickyRanges.coverageText(interval, earliest: data.performanceStartedAt == nil ? nil : earliest) {
+                Label(coverage, systemImage: "calendar.badge.clock").font(.caption).foregroundStyle(.secondary)
+            }
+            if range == ClickyRanges.custom {
                 HStack {
-                    DatePicker("From", selection: $start, displayedComponents: .date)
-                    DatePicker("Through", selection: $end, displayedComponents: .date)
+                    DatePicker("From", selection: Binding(get: { start }, set: { start = $0 }), displayedComponents: .date)
+                    DatePicker("Through", selection: Binding(get: { end }, set: { end = $0 }), displayedComponents: .date)
                 }.datePickerStyle(.field)
+                Text("Custom dates are saved. Grouping and weekday/hour filters reset when this page reopens.")
+                    .font(.caption).foregroundStyle(.secondary)
             }
-            NativeSettingsRow("Group timeline by") {
-                Picker("Grouping", selection: $grouping) {
-                    ForEach(ClickyPerformanceGrouping.allCases) { Text($0.label).tag($0) }
+            let groupings = ClickyRanges.groupings(for: interval, now: now)
+            NativeSettingsRow("Group timeline by",
+                detail: groupings.count < ClickyPerformanceGrouping.allCases.count
+                    ? "Minute detail is kept for 30 days, so this range groups by hour or wider." : nil) {
+                Picker("Grouping", selection: Binding(get: { grouping }, set: { requestedGrouping = $0 })) {
+                    ForEach(groupings) { Text($0.label).tag($0) }
                 }.labelsHidden().frame(width: 150, alignment: .trailing)
                     .accessibilityIdentifier("clicky.performance.grouping")
             }
             HStack {
                 Text("Weekdays").font(.system(size: 13, weight: .medium))
                 Spacer()
-                ForEach(0..<7, id: \.self) { day in
-                    Button(weekdayNames[day]) {
+                ForEach(ClickyWeekdays.order(), id: \.self) { day in
+                    Button(ClickyWeekdays.shortName(day)) {
                         if weekdays.contains(day) { weekdays.remove(day) } else { weekdays.insert(day) }
                     }.buttonStyle(.borderedProminent).tint(weekdays.contains(day) ? .mint : .gray)
                         .accessibilityValue(weekdays.contains(day) ? "Included" : "Excluded")
+                        .accessibilityAddTraits(weekdays.contains(day) ? .isSelected : [])
                         .accessibilityIdentifier("clicky.performance.weekday.\(day)")
                 }
             }
-            NativeSettingsRow("Hours", detail: "Start included, end excluded. A later start spans midnight.") {
+            NativeSettingsRow("Hours", detail: "Start included, end excluded. A later start spans midnight; the same hour twice means all day.") {
                 HStack(spacing: 8) {
                     NativeSettingsNumberPicker("From hour", range: 0..<24, identifier: "clicky.performance.fromHour", value: $fromHour)
-                    Text("→").foregroundStyle(.secondary)
+                    Text("to").foregroundStyle(.secondary)
                     NativeSettingsNumberPicker("Until hour", range: 1..<25, identifier: "clicky.performance.untilHour", value: $untilHour)
                 }
             }
+            HStack(spacing: 8) {
+                Text("Presets").font(.caption).foregroundStyle(.secondary)
+                Button("Weekdays") { weekdays = Set(0..<5) }.buttonStyle(.genHover())
+                Button("Weekend") { weekdays = [5, 6] }.buttonStyle(.genHover())
+                Button("Work hours") { fromHour = 9; untilHour = 17 }.buttonStyle(.genHover())
+                    .help("9:00 to 17:00")
+                Spacer()
+                Button("Reset Filters", action: resetFilters).buttonStyle(.genHover()).disabled(!filtered)
+                    .help(filtered ? "Include every day and every hour" : "No filter is set")
+            }
+        }
+    }
+
+    private func resetFilters() {
+        weekdays = Set(0..<7)
+        fromHour = 0
+        untilHour = 24
+    }
+
+    /// One line in words for the filters in force, shown where the results are.
+    private var filterSummary: String? {
+        guard filtered else { return nil }
+        let days = weekdays.count == 7 ? "every day"
+            : ClickyWeekdays.order().filter { weekdays.contains($0) }.map { ClickyWeekdays.shortName($0) }.joined(separator: ", ")
+        let hours = fromHour == 0 && untilHour == 24 ? "all day" : String(format: "%02d:00 to %02d:00", fromHour, untilHour % 24)
+        return "Filters: \(days.isEmpty ? "no day" : days), \(hours)"
+    }
+
+    private var emptyResult: some View {
+        let reason: String
+        if weekdays.isEmpty { reason = "No weekday is selected, so nothing can match." }
+        else if ClickyRanges.coveredDays(interval, earliest: earliest) == 0 { reason = "Nothing was recorded in this range." }
+        else if filtered { reason = "Your weekday and hour filters exclude every key press recorded in this range." }
+        else { reason = "No key press was recorded in this range." }
+        return HStack {
+            Label(reason, systemImage: "line.3.horizontal.decrease.circle").foregroundStyle(.orange)
+            Spacer()
+            if filtered { Button("Reset Filters", action: resetFilters).buttonStyle(.bordered) }
+        }.font(.system(size: 12))
+    }
+
+    private func numbers(_ report: ClickyPerformanceReport) -> some View {
+        let total = report.total
+        let previous = previousReport?.total
+        let name = previousName
+        let netPace = total.activeSeconds >= 1 ? total.estimatedRetainedWords * 60 / total.activeSeconds : nil
+        let days = max(1, ClickyRanges.coveredDays(interval, earliest: earliest))
+        return VStack(alignment: .leading, spacing: 8) {
+            if let summary = filterSummary {
+                HStack {
+                    Label(summary, systemImage: "line.3.horizontal.decrease.circle").font(.caption).foregroundStyle(.secondary)
+                    Spacer()
+                    Button("Reset", action: resetFilters).buttonStyle(.genHover()).font(.caption)
+                }
+            }
+            Grid(horizontalSpacing: 12, verticalSpacing: 12) {
+                GridRow {
+                    number("Presses", total.presses.formatted(), "keyboard", "Every key-down event",
+                        ClickyFormat.change(Double(total.presses), previous.map { Double($0.presses) }, against: name))
+                    number("Words typed", total.estimatedWords.formatted(.number.precision(.fractionLength(0))),
+                        "text.word.spacing", "5 text-like presses per word",
+                        ClickyFormat.change(total.estimatedWords, previous?.estimatedWords, against: name))
+                    number("Words kept", total.estimatedRetainedWords.formatted(.number.precision(.fractionLength(0))),
+                        "text.badge.checkmark", "Words typed minus delete presses",
+                        ClickyFormat.change(total.estimatedRetainedWords, previous?.estimatedRetainedWords, against: name))
+                }
+                GridRow {
+                    number("Typing time", ClickyFormat.duration(total.activeSeconds), "stopwatch",
+                        "Pauses over 5 seconds excluded",
+                        ClickyFormat.change(total.activeSeconds, previous?.activeSeconds, against: name))
+                    number("Pace", total.wordsPerMinute.map { String(format: "%.1f WPM", $0) } ?? ClickyFormat.missing,
+                        "speedometer", netPace.map { String(format: "%.1f WPM counting words kept", $0) } ?? "Words typed per minute of typing",
+                        total.wordsPerMinute.flatMap { ClickyFormat.change($0, previous?.wordsPerMinute, against: name) })
+                    number("Correction share", ClickyFormat.percent(total.correctionShare), "delete.left",
+                        "Delete presses of text and delete presses",
+                        ClickyFormat.pointChange(total.correctionShare, previous?.correctionShare, against: name))
+                }
+                GridRow {
+                    number("Typing sessions", total.sessions.formatted(), "rectangle.stack",
+                        "Text after a clock minute without text",
+                        ClickyFormat.change(Double(total.sessions), previous.map { Double($0.sessions) }, against: name))
+                    number("Average burst", total.bursts > 0 ? ClickyFormat.duration(total.activeSeconds / Double(total.bursts)) : ClickyFormat.missing,
+                        "waveform.path", "Typing time per started burst", nil)
+                    number("Active days", "\(report.activeDays.formatted()) of \(days.formatted())", "calendar",
+                        "Days with typing; \(ClickyFormat.duration(total.activeSeconds / Double(max(1, report.activeDays)))) per active day",
+                        nil)
+                }
+            }
         }
     }
 
-    private func number(_ title: String, _ value: String, _ symbol: String, _ detail: String) -> some View {
+    private func number(_ title: String, _ value: String, _ symbol: String, _ detail: String, _ change: String?) -> some View {
         NativeSettingsCard {
             Label(title, systemImage: symbol).font(.caption).foregroundStyle(.secondary)
             Text(value).font(.system(size: 22, weight: .semibold, design: .rounded)).monospacedDigit()
-            Text(detail).font(.caption2).foregroundStyle(.secondary)
+                .lineLimit(1).minimumScaleFactor(0.7)
+            Text(detail).font(.caption).foregroundStyle(.secondary).fixedSize(horizontal: false, vertical: true)
+            Text(change ?? " ").font(.caption).foregroundStyle(.secondary).monospacedDigit()
+                .accessibilityHidden(change == nil)
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .topLeading)
+        .accessibilityElement(children: .combine)
+    }
+
+    private func timelineValue(_ totals: ClickyPerformanceBucket) -> Double? {
+        switch metric {
+        case .presses: return Double(totals.presses)
+        case .words: return totals.estimatedWords
+        case .time: return totals.activeSeconds
+        case .pace: return totals.activeSeconds >= 30 ? totals.wordsPerMinute : nil
+        case .corrections: return totals.characters + totals.corrections >= 20 ? totals.correctionShare * 100 : nil
+        case .sessions: return Double(totals.sessions)
+        }
+    }
+
+    private var timelineFormat: ((Double) -> String)? {
+        switch metric {
+        case .time: return { ClickyFormat.duration($0) }
+        case .pace: return { String(format: "%.0f WPM", $0) }
+        case .corrections: return { String(format: "%.1f%%", $0) }
+        default: return nil
         }
     }
 
     private func timeline(_ report: ClickyPerformanceReport) -> some View {
-        NativeSettingsCard("Performance over time") {
-            Picker("Timeline metric", selection: $metric) {
-                ForEach(["Presses", "Estimated words", "Active seconds"], id: \.self) { Text($0).tag($0) }
-            }.pickerStyle(.segmented).accessibilityIdentifier("clicky.performance.metric")
-            NativeTimeSeriesChart(points: report.timeline.map { point in
-                let value = metric == "Presses" ? Double(point.totals.presses)
-                    : metric == "Estimated words" ? point.totals.estimatedWords : point.totals.activeSeconds
-                return NativeTimePoint(date: point.date, value: value)
+        NativeSettingsCard("Performance over time", subtitle: "\(range == ClickyRanges.custom ? "Custom range" : range) by \(grouping.label.lowercased())") {
+            Picker("Timeline metric", selection: Binding(get: { metric.rawValue }, set: { storedMetric = $0 })) {
+                ForEach(Metric.allCases, id: \.rawValue) { Text($0.rawValue).tag($0.rawValue) }
+            }.pickerStyle(.segmented).labelsHidden().accessibilityIdentifier("clicky.performance.metric")
+            NativeTimeSeriesChart(points: report.timeline.compactMap { point in
+                timelineValue(point.totals).map { NativeTimePoint(date: point.date, value: $0,
+                    weight: metric == .pace ? point.totals.activeSeconds
+                        : metric == .corrections ? Double(point.totals.characters + point.totals.corrections) : 1) }
             }, interval: Double(grouping.rawValue), initialWindow: Double(max(grouping.rawValue * 12, 3600)),
-                end: min(now, filter.end), valueLabel: metric)
-                .id("\(grouping.rawValue).\(range).\(example != nil)")
-            if report.timeline.isEmpty { Text("No recorded activity matches these filters.").font(.caption).foregroundStyle(.secondary) }
+                end: min(now, interval.end), valueLabel: metric.rawValue, rangeStart: interval.start,
+                combine: metric == .pace || metric == .corrections ? .average : .sum, valueFormat: timelineFormat,
+                style: $chartStyle)
+                .id("\(grouping.rawValue).\(range).\(interval.start.timeIntervalSince1970).\(example != nil)")
+            if metric == .pace || metric == .corrections {
+                Text(metric == .pace ? "Bars with less than 30 seconds of typing are left out."
+                    : "Bars with fewer than 20 text and delete presses are left out.")
+                    .font(.caption).foregroundStyle(.secondary)
+            }
         }
     }
 
-    private func dictation(_ totals: ClickyPerformanceBucket) -> some View {
-        let estimate = ClickyDictationEstimate(totals: totals, wordsPerMinute: spokenWPM, setupPerBurst: setupSeconds)
-        return NativeSettingsCard("Estimated time lost by writing instead of dictating",
-            subtitle: "A configurable what-if comparison, not a measurement of actual dictation.") {
-            HStack(alignment: .firstTextBaseline) {
-                Text(totals.activeSeconds > 0 ? duration(max(0, estimate.differenceSeconds)) : "—")
-                    .font(.system(size: 32, weight: .semibold, design: .rounded)).foregroundStyle(.mint)
-                Text("potential time saved").foregroundStyle(.secondary)
+    private func dictation(_ report: ClickyPerformanceReport) -> some View {
+        let totals = report.total
+        let estimate = ClickyDictationEstimate(totals: totals, wordsPerMinute: spokenWPM, setupPerSession: setupSeconds,
+            dictatedShare: Double(dictatedPercent) / 100, reviewShare: Double(reviewPercent) / 100)
+        let difference = estimate.differenceSeconds
+        let activeDays = max(1, report.activeDays)
+        let coveredDays = max(1, ClickyRanges.coveredDays(interval, earliest: earliest))
+        let parts = [
+            DictationPart(method: "Typing", part: "Typing", seconds: estimate.typingSeconds),
+            DictationPart(method: "Dictation", part: "Speaking", seconds: estimate.speakingSeconds),
+            DictationPart(method: "Dictation", part: "Setup", seconds: estimate.setupSeconds),
+            DictationPart(method: "Dictation", part: "Review", seconds: estimate.reviewSeconds),
+        ]
+        return NativeSettingsCard("Estimated time saved by dictating",
+            subtitle: "A what-if comparison under the settings below, not a measurement of real dictation.") {
+            if totals.activeSeconds <= 0 {
+                Text("No typing time in this range to compare.").foregroundStyle(.secondary)
+            } else if difference >= 0 {
+                HStack(alignment: .firstTextBaseline) {
+                    Text(ClickyFormat.duration(difference))
+                        .font(.system(size: 32, weight: .semibold, design: .rounded)).foregroundStyle(.mint).monospacedDigit()
+                    Text("saved in this range").foregroundStyle(.secondary)
+                }
+                Text("About \(ClickyFormat.duration(difference / Double(activeDays))) per active day, \(ClickyFormat.duration(difference / Double(coveredDays) * 7)) per week.")
+                    .font(.callout).foregroundStyle(.secondary)
+            } else {
+                Text("Typing is \(ClickyFormat.duration(-difference)) faster under these settings")
+                    .font(.system(size: 22, weight: .semibold, design: .rounded)).foregroundStyle(.orange)
+                Text("About \(ClickyFormat.duration(-difference / Double(activeDays))) per active day.")
+                    .font(.callout).foregroundStyle(.secondary)
             }
-            if estimate.differenceSeconds < 0 {
-                Text("Typing was \(duration(-estimate.differenceSeconds)) faster under these assumptions.")
-                    .font(.caption).foregroundStyle(.orange)
+            Chart(parts, id: \.part) { part in
+                BarMark(x: .value("Time", part.seconds), y: .value("Method", part.method))
+                    .foregroundStyle(by: .value("Part", part.part))
+                    .annotation(position: .overlay) {
+                        if part.seconds >= max(estimate.typingSeconds, estimate.dictationSeconds) * 0.12 && part.seconds > 0 {
+                            Text(ClickyFormat.duration(part.seconds)).font(.caption.weight(.semibold)).foregroundStyle(.black.opacity(0.8))
+                        }
+                    }
             }
-            Chart {
-                BarMark(x: .value("Seconds", estimate.typingSeconds), y: .value("Method", "Typing"))
-                    .foregroundStyle(by: .value("Component", "Active typing"))
-                BarMark(x: .value("Seconds", estimate.speakingSeconds), y: .value("Method", "Dictation"))
-                    .foregroundStyle(by: .value("Component", "Speaking"))
-                BarMark(x: .value("Seconds", estimate.setupSeconds), y: .value("Method", "Dictation"))
-                    .foregroundStyle(by: .value("Component", "Setup"))
-            }.chartForegroundStyleScale(["Active typing": Color.mint, "Speaking": Color.cyan, "Setup": Color.orange])
-                .frame(height: 110).chartXAxisLabel("Seconds")
-            NativeSettingsRow("Speech speed", detail: "Estimated retained words ÷ words per minute × 60") {
+            .chartForegroundStyleScale(["Typing": Color.mint, "Speaking": Color.cyan, "Setup": Color.orange, "Review": Color.purple])
+            .chartXAxis {
+                AxisMarks(values: .automatic(desiredCount: 4)) { value in
+                    AxisGridLine()
+                    AxisValueLabel { if let seconds = value.as(Double.self) { Text(ClickyFormat.duration(seconds)) } }
+                }
+            }
+            .frame(height: 120)
+            .accessibilityElement(children: .ignore)
+            .accessibilityLabel("Typing \(ClickyFormat.duration(estimate.typingSeconds)); dictation \(ClickyFormat.duration(estimate.dictationSeconds)): speaking \(ClickyFormat.duration(estimate.speakingSeconds)), setup \(ClickyFormat.duration(estimate.setupSeconds)), review \(ClickyFormat.duration(estimate.reviewSeconds))")
+            Text("\(estimate.retainedWords.formatted(.number.precision(.fractionLength(0)))) of \(totals.estimatedRetainedWords.formatted(.number.precision(.fractionLength(0)))) words kept would be dictated, in \(Int((Double(totals.sessions) * Double(dictatedPercent) / 100).rounded()).formatted()) of \(totals.sessions.formatted()) typing sessions.")
+                .font(.caption).foregroundStyle(.secondary)
+            NativeSettingsSlider("Share of your typing you would dictate",
+                detail: "Code, commands and passwords stay typed. Clicky cannot tell them apart, so you set the share.",
+                identifier: "clicky.performance.dictatedShare", value: percentBinding($dictatedPercent),
+                in: 0...100, step: 5, ticks: [0, 50, 100], width: 160, format: { "\(Int($0))%" })
+            NativeSettingsSlider("Review after dictation",
+                detail: "Reading and fixing the transcript, as a share of the speaking time.",
+                identifier: "clicky.performance.reviewShare", value: percentBinding($reviewPercent),
+                in: 0...100, step: 5, ticks: [0, 50, 100], width: 160, format: { "\(Int($0))%" })
+            NativeSettingsRow("Speech speed", detail: "Words kept divided by this speed give the speaking time.") {
                 HStack { NativeSettingsNumberPicker("Spoken words per minute", range: 60..<241,
                     identifier: "clicky.performance.speech", value: $spokenWPM); Text("WPM").font(.caption) }
             }
-            NativeSettingsRow("Setup per burst", detail: "One dictation activation for every typing burst") {
-                HStack { NativeSettingsNumberPicker("Setup seconds per burst", range: 0..<16,
+            NativeSettingsRow("Setup per session", detail: "One dictation start per typing session. A session starts at text after a clock minute without text.") {
+                HStack { NativeSettingsNumberPicker("Setup seconds per session", range: 0..<16,
                     identifier: "clicky.performance.setup", value: $setupSeconds); Text("sec").font(.caption) }
             }
-            Text("\(totals.bursts.formatted()) bursts × \(setupSeconds)s setup + \(duration(estimate.speakingSeconds)) speaking. Retained-word estimate: max(0, text-like presses − delete presses) ÷ 5; deleting a selection or undoing cannot be inferred. It excludes thinking time, transcription delay and review/corrections after dictation; it cannot tell prose from code.")
+            Text("Words kept are text-like presses minus delete presses, divided by 5; deleting a selection or undoing cannot be inferred. The estimate leaves out thinking time and transcription delay.")
                 .font(.caption).foregroundStyle(.secondary)
         }
     }
 
+    private struct DictationPart {
+        let method: String
+        let part: String
+        let seconds: Double
+    }
+
+    private func percentBinding(_ value: Binding<Int>) -> Binding<Double> {
+        Binding(get: { Double(value.wrappedValue) }, set: { value.wrappedValue = Int($0.rounded()) })
+    }
+
     private func pace(_ report: ClickyPerformanceReport) -> some View {
-        let values = comparison == "Time of day" ? report.hours : report.weekdays
-        let labels = comparison == "Time of day" ? (0..<24).map { String(format: "%02d", $0) } : weekdayNames
-        return NativeSettingsCard("Typing performance by \(comparison.lowercased())", subtitle: "Estimated words per active minute · filters above apply") {
-            Picker("Performance comparison", selection: $comparison) {
+        let byHour = comparison != "Weekday"
+        let order = ClickyWeekdays.order()
+        let entries: [(label: String, bucket: ClickyPerformanceBucket)] = byHour
+            ? report.hours.enumerated().map { (String(format: "%02d", $0.offset), $0.element) }
+            : order.map { (ClickyWeekdays.shortName($0), report.weekdays[$0]) }
+        let overall = report.total.wordsPerMinute
+        return NativeSettingsCard("Typing pace by \(byHour ? "time of day" : "weekday")", subtitle: "Words typed per minute of typing. Filters above apply.") {
+            Picker("Pace comparison", selection: $comparison) {
                 Text("Time of day").tag("Time of day")
                 Text("Weekday").tag("Weekday")
-            }.pickerStyle(.segmented).accessibilityIdentifier("clicky.performance.comparison")
-            Chart(Array(values.enumerated()), id: \.offset) { index, bucket in
-                if let pace = bucket.wordsPerMinute {
-                    BarMark(x: .value(comparison, labels[index]), y: .value("Estimated WPM", pace))
-                        .foregroundStyle(.mint.gradient)
+            }.pickerStyle(.segmented).labelsHidden().accessibilityIdentifier("clicky.performance.comparison")
+            Chart {
+                ForEach(entries, id: \.label) { entry in
+                    if entry.bucket.activeSeconds >= 60, let pace = entry.bucket.wordsPerMinute {
+                        BarMark(x: .value(byHour ? "Hour" : "Weekday", entry.label), y: .value("WPM", pace))
+                            .foregroundStyle(.mint.gradient)
+                            .opacity(entry.bucket.activeSeconds >= 300 ? 1 : 0.4)
+                            .accessibilityValue("\(String(format: "%.0f", pace)) words per minute over \(ClickyFormat.duration(entry.bucket.activeSeconds))")
+                    }
+                }
+                if let overall {
+                    RuleMark(y: .value("Overall", overall)).foregroundStyle(.secondary)
+                        .lineStyle(StrokeStyle(lineWidth: 1, dash: [4, 3]))
+                        .annotation(position: .top, alignment: .trailing) {
+                            Text(String(format: "Overall %.0f WPM", overall)).font(.caption).foregroundStyle(.secondary)
+                        }
                 }
-            }.frame(height: 200).chartYAxisLabel("Estimated WPM")
-            Text("Empty categories have insufficient timed input, not zero typing speed. Pace needs at least 5 text-like presses and 1 active second.")
-                .font(.caption2).foregroundStyle(.secondary)
+            }.frame(height: 200).chartYAxisLabel("WPM")
+            Text("A bar needs at least 1 minute of typing; faded bars have less than 5 minutes. An empty slot means too little typing, not a slow speed.")
+                .font(.caption).foregroundStyle(.secondary)
+        }
+    }
+
+    private func records(_ report: ClickyPerformanceReport) -> some View {
+        let records = ClickyRecords(days: report.days.mapValues { Double($0.presses) }, today: now)
+        let bestPace = report.days.filter { $0.value.activeSeconds >= 600 }
+            .compactMap { day in day.value.wordsPerMinute.map { (day.key, $0) } }.max { $0.1 < $1.1 }
+        let day = Date.FormatStyle.dateTime.weekday(.abbreviated).month(.abbreviated).day()
+        return NativeSettingsCard("Records in this range") {
+            Grid(alignment: .leading, horizontalSpacing: 18, verticalSpacing: 6) {
+                GridRow {
+                    Text("Busiest day").foregroundStyle(.secondary)
+                    Text(records.busiestDay.map { "\($0.formatted(day)): \(Int(records.busiestDayValue).formatted()) presses" } ?? ClickyFormat.missing)
+                }
+                GridRow {
+                    Text("Fastest day").foregroundStyle(.secondary)
+                    Text(bestPace.map { "\($0.0.formatted(day)): \(String(format: "%.1f", $0.1)) WPM" } ?? "Needs a day with 10 minutes of typing")
+                }
+                GridRow {
+                    Text("Longest streak").foregroundStyle(.secondary)
+                    Text("\(records.longestStreak) \(records.longestStreak == 1 ? "day" : "days") in a row with typing")
+                }
+                GridRow {
+                    Text("Current streak").foregroundStyle(.secondary)
+                    Text("\(records.currentStreak) \(records.currentStreak == 1 ? "day" : "days")")
+                }
+            }.font(.system(size: 12)).monospacedDigit()
         }
     }
 
     private func playful(_ totals: ClickyPerformanceBucket) -> some View {
         HStack(alignment: .top, spacing: 12) {
             fun("Tiny finger hike", symbol: "figure.walk", value: String(format: "%.1f m", Double(totals.presses) * 0.002),
-                progress: Double(totals.presses) * 0.002 / 1000, caption: "Toward 1 km · pretend 2 mm per press")
+                progress: Double(totals.presses) * 0.002 / 1000, caption: "Toward 1 km, pretending 2 mm per press")
             fun("Accidental novelist", symbol: "book.closed", value: String(format: "%.1f pages", totals.estimatedWords / 250),
-                progress: totals.estimatedWords / 80000, caption: "Toward a novel · 80k words, 250 per page")
-            fun("One-key concert", symbol: "music.note", value: duration(Double(totals.presses) / 2),
-                progress: Double(totals.presses) / (120 * 60), caption: "Toward a 1-hour set · 120 presses per minute")
+                progress: totals.estimatedWords / 80000, caption: "Toward a novel: 80k words, 250 per page")
+            fun("One-key concert", symbol: "music.note", value: ClickyFormat.duration(Double(totals.presses) / 2),
+                progress: Double(totals.presses) / (120 * 60), caption: "Toward a 1-hour set at 120 presses per minute")
         }
     }
     private func fun(_ title: String, symbol: String, value: String, progress: Double, caption: String) -> some View {
         NativeSettingsCard {
-            Image(systemName: symbol).font(.title2).foregroundStyle(.purple)
+            Image(systemName: symbol).font(.title2).foregroundStyle(.purple).accessibilityHidden(true)
             Text(title).font(.headline)
             Text(value).font(.system(size: 20, weight: .semibold, design: .rounded)).monospacedDigit()
             ProgressView(value: min(1, max(0, progress))).tint(.purple)
-            Text(caption).font(.caption2).foregroundStyle(.secondary)
-            Text("Just for fun").font(.caption2).foregroundStyle(.purple)
-        }
+            Text(caption).font(.caption).foregroundStyle(.secondary)
+            Text("Just for fun").font(.caption).foregroundStyle(.purple)
+        }.accessibilityElement(children: .combine)
     }
-    private func duration(_ seconds: Double) -> String {
-        guard seconds.isFinite else { return "—" }
-        let value = max(0, Int(seconds.rounded()))
-        if value >= 3600 { return "\(value / 3600)h \((value % 3600) / 60)m" }
-        if value >= 60 { return "\(value / 60)m \(value % 60)s" }
-        return "\(value)s"
+}
+
+/// "Not recording: …" with the button that fixes it.
+struct ClickyRecordingBanner: View {
+    let message: String
+    let actionTitle: String
+    let action: (() -> Void)?
+
+    var body: some View {
+        HStack(spacing: 12) {
+            Label(message, systemImage: "pause.circle.fill").font(.system(size: 12)).foregroundStyle(.orange)
+            Spacer(minLength: 0)
+            if let action, !actionTitle.isEmpty { Button(actionTitle, action: action).buttonStyle(.bordered) }
+        }
+        .padding(12).nativeGlassSurface()
+        .accessibilityElement(children: .contain)
+        .accessibilityIdentifier("clicky.recordingStatus")
     }
 }
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyRanges.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyRanges.swift
new file mode 100644
index 0000000000..45974ce76a
--- /dev/null
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyRanges.swift
@@ -0,0 +1,278 @@
+import Foundation
+
+/// The date ranges both statistics pages offer, and the arithmetic around them: the interval a range covers, the
+/// previous period of the same length, how much of it has recorded data. One place, so the Stats and Performance
+/// pages cannot drift apart.
+enum ClickyRanges {
+    static let today = "Today"
+    static let week = "7 days"
+    static let month = "30 days"
+    static let quarter = "90 days"
+    static let year = "1 year"
+    static let all = "All kept data"
+    static let custom = "Custom"
+    static let presets = [today, week, month, quarter, year, all]
+
+    /// A stored range name, or the default when the stored one is unknown (an older name such as "All time").
+    static func known(_ range: String, allowed: [String]) -> String {
+        if range == "All time" { return all }
+        return allowed.contains(range) ? range : week
+    }
+
+    /// The interval a range covers. Presets end now; Custom covers whole days, `customEnd` included.
+    static func interval(_ range: String, now: Date, earliest: Date?, customStart: Date = Date(),
+        customEnd: Date = Date(), calendar: Calendar = .current) -> DateInterval {
+        let today = calendar.startOfDay(for: now)
+        let start: Date
+        switch range {
+        case Self.today: start = today
+        case month: start = calendar.date(byAdding: .day, value: -29, to: today) ?? today
+        case quarter: start = calendar.date(byAdding: .day, value: -89, to: today) ?? today
+        case year: start = calendar.date(byAdding: .year, value: -1, to: today) ?? today
+        case all: start = calendar.startOfDay(for: min(earliest ?? now, now))
+        case custom: start = calendar.startOfDay(for: customStart)
+        default: start = calendar.date(byAdding: .day, value: -6, to: today) ?? today
+        }
+        let end = range == custom
+            ? calendar.date(byAdding: .day, value: 1, to: calendar.startOfDay(for: customEnd)) ?? now : now
+        return DateInterval(start: start, end: max(start, end))
+    }
+
+    /// Calendar days the interval touches (a range that ends now counts today).
+    static func dayCount(_ interval: DateInterval, calendar: Calendar = .current) -> Int {
+        guard interval.end > interval.start else { return 0 }
+        let first = calendar.startOfDay(for: interval.start)
+        let last = calendar.startOfDay(for: interval.end.addingTimeInterval(-1))
+        return (calendar.dateComponents([.day], from: first, to: last).day ?? 0) + 1
+    }
+
+    /// The period of the same length right before: Today compares with yesterday until the same time, 7 days with
+    /// the 7 days before. "All kept data" has nothing before it.
+    static func previous(_ interval: DateInterval, range: String, calendar: Calendar = .current) -> DateInterval? {
+        guard range != all else { return nil }
+        let days = dayCount(interval, calendar: calendar)
+        guard days > 0, let start = calendar.date(byAdding: .day, value: -days, to: interval.start),
+            let end = calendar.date(byAdding: .day, value: -days, to: interval.end) else { return nil }
+        return DateInterval(start: start, end: end)
+    }
+
+    /// "yesterday", "the previous 7 days": the words a comparison uses.
+    static func previousName(_ interval: DateInterval, range: String, calendar: Calendar = .current) -> String {
+        let days = dayCount(interval, calendar: calendar)
+        if range == today { return "yesterday" }
+        if range == year { return "the year before" }
+        return days == 1 ? "the day before" : "the previous \(days) days"
+    }
+
+    /// Days of the interval from the first recorded day on; `earliest == nil` means nothing was recorded.
+    static func coveredDays(_ interval: DateInterval, earliest: Date?, calendar: Calendar = .current) -> Int {
+        guard let earliest, earliest < interval.end else { return 0 }
+        let start = max(interval.start, calendar.startOfDay(for: earliest))
+        return dayCount(DateInterval(start: start, end: interval.end), calendar: calendar)
+    }
+
+    /// One line under the range picker when the range reaches before the first recorded day; nil when it is whole.
+    static func coverageText(_ interval: DateInterval, earliest: Date?, calendar: Calendar = .current) -> String? {
+        let total = dayCount(interval, calendar: calendar)
+        let covered = coveredDays(interval, earliest: earliest, calendar: calendar)
+        guard covered < total else { return nil }
+        if covered == 0 { return "Nothing was recorded in this range yet." }
+        return "Recorded data covers \(covered) of the \(total) days in this range."
+    }
+
+    /// The timeline grouping a range opens with: about 50 to 400 bars, never one bar per minute over a year.
+    static func grouping(for range: String, span: TimeInterval = 0) -> ClickyPerformanceGrouping {
+        switch range {
+        case today: return .fifteenMinutes
+        case week: return .hour
+        case month, quarter: return .day
+        case year, all: return .week
+        case custom:
+            if span <= 86400 * 1.5 { return .fifteenMinutes }
+            if span <= 86400 * 8 { return .hour }
+            if span <= 86400 * 200 { return .day }
+            return .week
+        default: return .day
+        }
+    }
+
+    /// Minute detail exists only for the last `performanceMinuteDays`; an older range offers hour bars and wider.
+    static func hasMinuteDetail(_ interval: DateInterval, now: Date) -> Bool {
+        interval.start >= now.addingTimeInterval(-Double(ClickyStatistics.performanceMinuteDays) * 86400)
+    }
+
+    static func groupings(for interval: DateInterval, now: Date) -> [ClickyPerformanceGrouping] {
+        hasMinuteDetail(interval, now: now) ? ClickyPerformanceGrouping.allCases
+            : ClickyPerformanceGrouping.allCases.filter { $0.rawValue >= 3600 }
+    }
+
+    static func validGrouping(_ preferred: ClickyPerformanceGrouping, for interval: DateInterval,
+        now: Date) -> ClickyPerformanceGrouping {
+        let allowed = groupings(for: interval, now: now)
+        return allowed.contains(preferred) ? preferred : (allowed.first ?? .hour)
+    }
+
+    /// The Stats activity chart's opening resolution for a range.
+    static func resolution(for range: String) -> ClickyTimeResolution {
+        switch range {
+        case today: return .minute
+        case week: return .hour
+        default: return .day
+        }
+    }
+
+    static func resolutions(for interval: DateInterval, now: Date) -> [ClickyTimeResolution] {
+        if interval.start < now.addingTimeInterval(-366 * 86400) { return [.day] }
+        return hasMinuteDetail(interval, now: now) ? ClickyTimeResolution.allCases : [.hour, .day]
+    }
+}
+
+/// What Clicky keeps, said once for every page.
+enum ClickyRetention {
+    /// Daily history expires by calendar day; a partially expired first day has already lost its daily bucket.
+    static func historyStart(_ statistics: ClickyStatistics, now: Date, calendar: Calendar = .current) -> Date? {
+        let cutoff = calendar.date(byAdding: .day, value: -730, to: now) ?? now
+        let day = calendar.startOfDay(for: cutoff)
+        let boundary = cutoff > day ? (calendar.date(byAdding: .day, value: 1, to: day) ?? cutoff) : day
+        let firstBucket = statistics.days.keys.min().map { Date(timeIntervalSince1970: Double($0)) }
+        guard let recorded = statistics.historyStartedAt ?? firstBucket else { return nil }
+        return max(recorded, boundary)
+    }
+
+    static func performanceStart(_ statistics: ClickyStatistics, now: Date) -> Date? {
+        let boundary = Date(timeIntervalSince1970: floor(now.timeIntervalSince1970 / 3600) * 3600
+            - Double(ClickyStatistics.performanceHourDays) * 86400)
+        let hour = statistics.performanceHours.keys.min().map { Date(timeIntervalSince1970: Double($0) * 3600) }
+        let minute = statistics.performanceMinutes.keys.min().map { Date(timeIntervalSince1970: Double($0) * 60) }
+        guard let recorded = statistics.performanceStartedAt ?? [hour, minute].compactMap({ $0 }).min() else { return nil }
+        return max(recorded, boundary)
+    }
+
+    static let text = "Clicky keeps minute detail for 30 days, hourly key counts for 1 year, hourly typing performance for 2 years and daily key counts for 2 years. Older detail is removed; lifetime totals stay."
+}
+
+/// Weekdays in the user's calendar order. Clicky stores weekday indexes with 0 = Monday.
+enum ClickyWeekdays {
+    /// Monday-based indexes, starting at the calendar's first weekday.
+    static func order(_ calendar: Calendar = .current) -> [Int] {
+        let first = (calendar.firstWeekday + 5) % 7
+        return (0..<7).map { (first + $0) % 7 }
+    }
+
+    static func shortName(_ index: Int, calendar: Calendar = .current) -> String {
+        calendar.shortWeekdaySymbols[(index + 1) % 7]
+    }
+
+    static func name(_ index: Int, calendar: Calendar = .current) -> String {
+        calendar.weekdaySymbols[(index + 1) % 7]
+    }
+
+    /// Monday-based index of a date.
+    static func index(of date: Date, calendar: Calendar = .current) -> Int {
+        (calendar.component(.weekday, from: date) + 5) % 7
+    }
+}
+
+enum ClickyFormat {
+    static let missing = "n/a"
+
+    static func duration(_ seconds: Double) -> String {
+        guard seconds.isFinite else { return missing }
+        let value = max(0, Int(seconds.rounded()))
+        if value >= 3600 { return "\(value / 3600)h \((value % 3600) / 60)m" }
+        if value >= 60 { return "\(value / 60)m \(value % 60)s" }
+        return "\(value)s"
+    }
+
+    static func percent(_ share: Double) -> String {
+        share.formatted(.percent.precision(.fractionLength(1)))
+    }
+
+    /// "Up 12% from the previous 7 days"; nil when there is nothing to compare with.
+    static func change(_ current: Double, _ previous: Double?, against name: String) -> String? {
+        guard let previous, previous > 0, current.isFinite else { return nil }
+        let ratio = (current - previous) / previous
+        if abs(ratio) < 0.005 { return "Same as \(name)" }
+        let amount = abs(ratio).formatted(.percent.precision(.fractionLength(0)))
+        return "\(ratio > 0 ? "Up" : "Down") \(amount) from \(name)"
+    }
+
+    /// A change of a share in percentage points: "Down 1.2 pt from yesterday".
+    static func pointChange(_ current: Double, _ previous: Double?, against name: String) -> String? {
+        guard let previous, previous > 0 || current > 0 else { return nil }
+        let points = (current - previous) * 100
+        if abs(points) < 0.05 { return "Same as \(name)" }
+        return "\(points > 0 ? "Up" : "Down") \(String(format: "%.1f", abs(points))) pt from \(name)"
+    }
+}
+
+/// Busiest day and streaks of days with typing, from daily totals.
+struct ClickyRecords: Equatable, Sendable {
+    var busiestDay: Date?
+    var busiestDayValue = 0.0
+    var longestStreak = 0
+    var currentStreak = 0
+
+    init(days: [Date: Double], today: Date, calendar: Calendar = .current) {
+        let active = days.filter { $0.value > 0 }
+        if let best = active.max(by: { $0.value == $1.value ? $0.key > $1.key : $0.value < $1.value }) {
+            busiestDay = best.key
+            busiestDayValue = best.value
+        }
+        let sorted = Set(active.keys.map { calendar.startOfDay(for: $0) }).sorted()
+        var run = 0
+        var previous: Date?
+        for day in sorted {
+            if let previous, calendar.date(byAdding: .day, value: 1, to: previous) == day { run += 1 } else { run = 1 }
+            longestStreak = max(longestStreak, run)
+            previous = day
+        }
+        let set = Set(sorted)
+        var cursor = calendar.startOfDay(for: today)
+        if !set.contains(cursor) { cursor = calendar.date(byAdding: .day, value: -1, to: cursor) ?? cursor }
+        while set.contains(cursor) {
+            currentStreak += 1
+            guard let next = calendar.date(byAdding: .day, value: -1, to: cursor) else { break }
+            cursor = next
+        }
+    }
+}
+
+/// Whether Clicky records statistics right now, and if not, why.
+public enum ClickyRecordingStatus: Equatable, Sendable {
+    case recording, clickyOff, inputMonitoringMissing, statisticsOff
+    case takingBreak, quietHours, excludedApplication, macSleeping
+
+    static func pause(systemSleeping: Bool, takingBreak: Bool, quiet: Bool, excluded: Bool) -> Self? {
+        if systemSleeping { return .macSleeping }
+        if takingBreak { return .takingBreak }
+        if quiet { return .quietHours }
+        if excluded { return .excludedApplication }
+        return nil
+    }
+
+    var message: String? {
+        switch self {
+        case .recording: return nil
+        case .clickyOff: return "Not recording: Clicky is off, so no key presses are counted."
+        case .inputMonitoringMissing: return "Not recording: Input Monitoring is not allowed for Clicky."
+        case .statisticsOff: return "Not recording: Keep local statistics is off."
+        case .takingBreak: return "Not recording: Clicky is taking a break."
+        case .quietHours: return "Not recording: Quiet hours are active."
+        case .excludedApplication: return "Not recording: This application is muted. Switch to another application to resume."
+        case .macSleeping: return "Not recording: Your Mac or display is asleep."
+        }
+    }
+
+    var actionTitle: String {
+        switch self {
+        case .recording: return ""
+        case .clickyOff: return "Turn On Clicky"
+        case .inputMonitoringMissing: return "Allow Input Monitoring"
+        case .statisticsOff: return "Turn On Statistics"
+        case .takingBreak: return "Resume Clicky"
+        case .quietHours: return "Turn Off Quiet Hours"
+        case .excludedApplication, .macSleeping: return ""
+        }
+    }
+}
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickySettings.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickySettings.swift
index a15a036477..7285aba4e7 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickySettings.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickySettings.swift
@@ -56,14 +56,59 @@ public struct ClickyPreferences: Codable, Equatable {
     public var collectStats = true
     public var reduceMotion = false
     public var reduceTransparency = false
+    /// The output Clicky plays on; nil follows the system output (and its rules).
+    public var outputDeviceUID: String?
+    public var outputDeviceName: String?
+    public var outputRules: [ClickyOutputRule] = []
+    /// Offer another output when the one Clicky plays on is late by more than `delayWarningMilliseconds`.
+    public var delayWarning = true
+    public var delayWarningMilliseconds = 150
+    /// Zero keeps the prompt visible until dismissed.
+    public var delayPromptSeconds = 45
+    /// Outputs the user chose to keep although they are late: never offered again.
+    public var delayAcceptedUIDs: [String] = []
 
     public init() {}
 
+    /// Every key is optional, so preferences saved by an older build keep their values and take the new defaults.
+    public init(from decoder: Decoder) throws {
+        self.init()
+        let values = try decoder.container(keyedBy: CodingKeys.self)
+        func read<T: Decodable>(_ key: CodingKeys, into field: inout T) throws {
+            if let value = try values.decodeIfPresent(T.self, forKey: key) { field = value }
+        }
+        try read(.selectedSwitch, into: &selectedSwitch)
+        selectedPack = try values.decodeIfPresent(ClickyPackReference.self, forKey: .selectedPack)
+        try read(.volume, into: &volume)
+        try read(.releaseSounds, into: &releaseSounds)
+        try read(.randomizedPitch, into: &randomizedPitch)
+        try read(.spatialAudio, into: &spatialAudio)
+        try read(.repeatSounds, into: &repeatSounds)
+        try read(.quietHours, into: &quietHours)
+        try read(.quietStart, into: &quietStart)
+        try read(.quietEnd, into: &quietEnd)
+        try read(.excludedApplications, into: &excludedApplications)
+        try read(.visualizer, into: &visualizer)
+        try read(.notifications, into: &notifications)
+        try read(.collectStats, into: &collectStats)
+        try read(.reduceMotion, into: &reduceMotion)
+        try read(.reduceTransparency, into: &reduceTransparency)
+        outputDeviceUID = try values.decodeIfPresent(String.self, forKey: .outputDeviceUID)
+        outputDeviceName = try values.decodeIfPresent(String.self, forKey: .outputDeviceName)
+        try read(.outputRules, into: &outputRules)
+        try read(.delayWarning, into: &delayWarning)
+        try read(.delayWarningMilliseconds, into: &delayWarningMilliseconds)
+        try read(.delayPromptSeconds, into: &delayPromptSeconds)
+        try read(.delayAcceptedUIDs, into: &delayAcceptedUIDs)
+    }
+
     public mutating func normalize() {
         volume = volume.isFinite ? min(1, max(0, volume)) : 0.45
         quietStart = min(1439, max(0, quietStart))
         quietEnd = min(1439, max(0, quietEnd))
         excludedApplications = Array(Set(excludedApplications.filter { !$0.isEmpty })).sorted()
+        delayWarningMilliseconds = min(5000, max(20, delayWarningMilliseconds))
+        delayPromptSeconds = min(300, max(0, delayPromptSeconds))
     }
 
     public func isQuiet(at date: Date, calendar: Calendar = .current) -> Bool {
@@ -101,6 +146,8 @@ public struct ClickyStatistics: Codable, Equatable, Sendable {
     public var days: [Int: ClickyActivityBucket] = [:]
     public var keys: [Int: Int] = [:]
     public var performanceMinutes: [Int: ClickyPerformanceBucket] = [:]
+    /// Hourly totals of the minutes older than `performanceMinuteDays`, kept for `performanceHourDays`.
+    public var performanceHours: [Int: ClickyPerformanceBucket] = [:]
     public var performanceStartedAt: Date?
     var lastTypingAt: Date?
     private var latestMinute = 0
@@ -109,7 +156,7 @@ public struct ClickyStatistics: Codable, Equatable, Sendable {
 
     private enum CodingKeys: String, CodingKey {
         case presses, releases, sessions, startedAt, historyStartedAt, minutes, hours, days, keys
-        case performanceMinutes, performanceStartedAt
+        case performanceMinutes, performanceHours, performanceStartedAt
     }
 
     public init(from decoder: Decoder) throws {
@@ -124,6 +171,7 @@ public struct ClickyStatistics: Codable, Equatable, Sendable {
         days = try values.decodeIfPresent([Int: ClickyActivityBucket].self, forKey: .days) ?? [:]
         keys = try values.decodeIfPresent([Int: Int].self, forKey: .keys) ?? [:]
         performanceMinutes = try values.decodeIfPresent([Int: ClickyPerformanceBucket].self, forKey: .performanceMinutes) ?? [:]
+        performanceHours = try values.decodeIfPresent([Int: ClickyPerformanceBucket].self, forKey: .performanceHours) ?? [:]
         performanceStartedAt = try values.decodeIfPresent(Date.self, forKey: .performanceStartedAt)
         latestMinute = minutes.keys.max() ?? 0
     }
@@ -132,7 +180,8 @@ public struct ClickyStatistics: Codable, Equatable, Sendable {
         lhs.presses == rhs.presses && lhs.releases == rhs.releases && lhs.sessions == rhs.sessions
             && lhs.startedAt == rhs.startedAt && lhs.historyStartedAt == rhs.historyStartedAt
             && lhs.minutes == rhs.minutes && lhs.hours == rhs.hours && lhs.days == rhs.days && lhs.keys == rhs.keys
-            && lhs.performanceMinutes == rhs.performanceMinutes && lhs.performanceStartedAt == rhs.performanceStartedAt
+            && lhs.performanceMinutes == rhs.performanceMinutes && lhs.performanceHours == rhs.performanceHours
+            && lhs.performanceStartedAt == rhs.performanceStartedAt
     }
 
     public mutating func record(keyCode: UInt16, release: Bool, at date: Date = Date(), calendar: Calendar = .current,
@@ -150,7 +199,7 @@ public struct ClickyStatistics: Codable, Equatable, Sendable {
         let retentionHour = latestMinute / 60
         if prunedHour != retentionHour {
             minutes = minutes.filter { $0.key >= latestMinute - 30 * 24 * 60 }
-            performanceMinutes = performanceMinutes.filter { $0.key >= latestMinute - 30 * 24 * 60 }
+            rollUpPerformance(olderThan: latestMinute - Self.performanceMinuteDays * 24 * 60)
             hours = hours.filter { $0.key >= retentionHour - 366 * 24 }
             let oldestDay = calendar.date(byAdding: .day, value: -730, to: date) ?? date
             days = days.filter { $0.key >= Int(oldestDay.timeIntervalSince1970) }
diff --git a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyViews.swift b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyViews.swift
index 30bad7fab2..a1df6d934a 100644
--- a/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyViews.swift
+++ b/src/macos/GenesisKit/Sources/GenesisKit/Clicky/ClickyViews.swift
@@ -127,7 +127,8 @@ private struct ClickySettingsPageContent: View {
                 if model.statisticsLoadError == nil { stats } else { historyRecovery }
             case .performance:
                 if model.statisticsLoadError == nil {
-                    ClickyPerformanceView(store: model.analytics, defaults: model.settingsDefaults)
+                    ClickyPerformanceView(store: model.analytics, defaults: model.settingsDefaults,
+                        status: model.recordingStatus, fixRecording: model.fixRecording)
                 } else {
                     historyRecovery
                 }
@@ -255,6 +256,7 @@ private struct ClickySettingsPageContent: View {
                 }
             }
             ClickySoundLibraryView(model: model, library: model.soundLibrary)
+            ClickyOutputCard(model: model)
             card("Sound behavior") {
                 setting(
                     "Key release sounds", detail: "A separate sound when each key comes back up.",
@@ -375,13 +377,14 @@ private struct ClickySettingsPageContent: View {
 
     private var stats: some View {
         VStack(spacing: 18) {
-            ClickyAnalyticsView(store: model.analytics)
+            ClickyAnalyticsView(store: model.analytics, defaults: model.settingsDefaults,
+                status: model.recordingStatus, fixRecording: model.fixRecording)
             card("Privacy") {
                 setting(
                     "Keep local statistics",
                     detail: "Minute and hour totals, daily totals and aggregate physical-key counts. No typed text, key sequence or application history.",
                     value: $model.preferences.collectStats)
-                Text("Minute history: 30 days · Hourly: 1 year · Daily: 2 years. Earlier lifetime totals are preserved without inventing historical detail.")
+                Text(ClickyRetention.text)
                     .font(.caption).foregroundStyle(.secondary)
                 Text("Counts are recorded while Clicky is listening. Paused or muted applications and Secure Input are not counted.")
                     .font(.caption).foregroundStyle(.secondary)
diff --git a/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyOutputTests.swift b/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyOutputTests.swift
new file mode 100644
index 0000000000..c564b50590
--- /dev/null
+++ b/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyOutputTests.swift
@@ -0,0 +1,162 @@
+import AppKit
+import CoreAudio
+import SwiftUI
+import XCTest
+
+@testable import GenesisKit
+
+/// Where Clicky plays: a picked device, a rule for the system output, or the system output; and which output the
+/// late-output prompt offers.
+@MainActor
+final class ClickyOutputTests: XCTestCase {
+    private let speakers = AudioOutputDevice(id: 1, uid: "BuiltInSpeakerDevice", name: "MacBook Pro Speakers",
+                                              transport: kAudioDeviceTransportTypeBuiltIn, delay: 0.027)
+    private let homePod = AudioOutputDevice(id: 2, uid: "airplay-work", name: "AirPlay",
+                                             transport: kAudioDeviceTransportTypeAirPlay, delay: 2.012)
+    private let monitor = AudioOutputDevice(id: 3, uid: "hdmi-monitor", name: "Monitor",
+                                             transport: kAudioDeviceTransportTypeHDMI, delay: 0.019)
+    private let loopback = AudioOutputDevice(id: 4, uid: "virtual", name: "Loopback",
+                                              transport: kAudioDeviceTransportTypeVirtual, delay: 0.011)
+    private var all: [AudioOutputDevice] { [speakers, homePod, monitor, loopback] }
+
+    func testWithNoChoiceClickyFollowsTheSystemOutput() {
+        let resolved = ClickyOutputRouting.resolve(preferences: ClickyPreferences(), outputs: all, systemID: homePod.id)
+        XCTAssertNil(resolved.device)
+        XCTAssertEqual(resolved.effective, homePod)
+    }
+
+    func testARuleForTheSystemOutputPlaysOnItsTarget() {
+        var preferences = ClickyPreferences()
+        preferences.outputRules = [ClickyOutputRule(whenUID: homePod.uid, whenName: homePod.name,
+                                                    playOnUID: speakers.uid, playOnName: speakers.name)]
+        XCTAssertEqual(ClickyOutputRouting.resolve(preferences: preferences, outputs: all, systemID: homePod.id).effective,
+                       speakers)
+        XCTAssertEqual(ClickyOutputRouting.resolve(preferences: preferences, outputs: all, systemID: monitor.id).effective,
+                       monitor, "a rule applies only while the system plays on its output")
+    }
+
+    func testAPickedDeviceWinsOverRulesAndFallsBackWhenGone() {
+        var preferences = ClickyPreferences()
+        preferences.outputDeviceUID = monitor.uid
+        preferences.outputDeviceName = monitor.name
+        preferences.outputRules = [ClickyOutputRule(whenUID: homePod.uid, whenName: homePod.name,
+                                                    playOnUID: speakers.uid, playOnName: speakers.name)]
+        XCTAssertEqual(ClickyOutputRouting.resolve(preferences: preferences, outputs: all, systemID: homePod.id).effective,
+                       monitor)
+        let gone = ClickyOutputRouting.resolve(preferences: preferences, outputs: [speakers, homePod], systemID: homePod.id)
+        XCTAssertEqual(gone.effective, homePod)
+        XCTAssertTrue(gone.reason.contains("not connected"), gone.reason)
+    }
+
+    func testAcceptingFasterOutputReplacesTheActiveRuleOrDisconnectedPick() {
+        var preferences = ClickyPreferences()
+        preferences.outputRules = [ClickyOutputRule(whenUID: monitor.uid, whenName: monitor.name,
+            playOnUID: homePod.uid, playOnName: homePod.name)]
+        let routed = ClickyOutputRouting.resolve(preferences: preferences, outputs: all, systemID: monitor.id)
+        let updated = ClickyOutputRouting.acceptingFasterOutput(speakers, preferences: preferences, resolution: routed)
+        XCTAssertEqual(updated.outputRules.count, 1)
+        XCTAssertEqual(updated.outputRules.first?.whenUID, monitor.uid)
+        XCTAssertEqual(ClickyOutputRouting.resolve(preferences: updated, outputs: all, systemID: monitor.id).effective, speakers)
+
+        preferences.outputDeviceUID = "disconnected"
+        let fallback = ClickyOutputRouting.resolve(preferences: preferences, outputs: all, systemID: homePod.id)
+        let picked = ClickyOutputRouting.acceptingFasterOutput(speakers, preferences: preferences, resolution: fallback)
+        XCTAssertEqual(picked.outputDeviceUID, speakers.uid)
+        XCTAssertEqual(ClickyOutputRouting.resolve(preferences: picked, outputs: all, systemID: homePod.id).effective, speakers)
+
+        let system = ClickyOutputRouting.resolve(preferences: ClickyPreferences(), outputs: all, systemID: homePod.id)
+        let followed = ClickyOutputRouting.acceptingFasterOutput(speakers, preferences: ClickyPreferences(), resolution: system)
+        XCTAssertNil(followed.outputDeviceUID)
+        XCTAssertEqual(ClickyOutputRouting.resolve(preferences: followed, outputs: all, systemID: homePod.id).effective, speakers)
+    }
+
+    func testTheSuggestionPrefersBuiltInSpeakersAndNeverAVirtualDevice() {
+        XCTAssertEqual(AudioOutputs.suggestion(instead: homePod, outputs: all, limit: 0.15), speakers)
+        XCTAssertEqual(AudioOutputs.suggestion(instead: homePod, outputs: [homePod, monitor, loopback], limit: 0.15),
+                       monitor)
+        XCTAssertNil(AudioOutputs.suggestion(instead: homePod, outputs: [homePod, loopback], limit: 0.15))
+    }
+
+    func testPreferencesSavedBeforeOutputsKeepTheirValues() throws {
+        let old = #"{"selectedSwitch":"ember","volume":0.8,"releaseSounds":false,"randomizedPitch":true,"spatialAudio":true,"repeatSounds":false,"quietHours":false,"quietStart":1320,"quietEnd":480,"excludedApplications":[],"visualizer":true,"notifications":false,"collectStats":true,"reduceMotion":false,"reduceTransparency":false}"#
+        let decoded = try JSONDecoder().decode(ClickyPreferences.self, from: Data(old.utf8))
+        XCTAssertEqual(decoded.selectedSwitch, .ember)
+        XCTAssertEqual(decoded.volume, 0.8)
+        XCTAssertFalse(decoded.releaseSounds)
+        XCTAssertNil(decoded.outputDeviceUID)
+        XCTAssertTrue(decoded.delayWarning)
+        XCTAssertEqual(decoded.delayWarningMilliseconds, 150)
+        XCTAssertEqual(decoded.delayPromptSeconds, 45)
+        var changed = decoded
+        changed.delayPromptSeconds = 0
+        changed.outputRules = [ClickyOutputRule(whenUID: "a", whenName: "A", playOnUID: "b", playOnName: "B")]
+        let again = try JSONDecoder().decode(ClickyPreferences.self, from: JSONEncoder().encode(changed))
+        XCTAssertEqual(again, changed)
+    }
+
+    func testPromptDurationNormalizesAndKeepsUntilDismissed() {
+        var preferences = ClickyPreferences()
+        preferences.delayPromptSeconds = -1
+        preferences.normalize()
+        XCTAssertEqual(preferences.delayPromptSeconds, 0)
+        preferences.delayPromptSeconds = 900
+        preferences.normalize()
+        XCTAssertEqual(preferences.delayPromptSeconds, 300)
+        preferences.delayPromptSeconds = 120
+        preferences.normalize()
+        XCTAssertEqual(preferences.delayPromptSeconds, 120)
+    }
+
+    func testDelayText() {
+        XCTAssertEqual(homePod.delayText, "2.0 s late")
+        XCTAssertEqual(speakers.delayText, "27 ms late")
+    }
+
+    /// Renders the prompt for the report: `CLICKY_PROMPT_SHOT=<png path>`.
+    @MainActor
+    func testThePromptRendersItsQuestion() throws {
+        let view = ClickyDelayPromptView(late: homePod, suggestion: speakers, onSwitch: {}, onKeep: {}, onClose: {})
+            .environment(\.colorScheme, .dark)
+        let host = NSHostingView(rootView: view)
+        host.frame = CGRect(origin: .zero, size: host.fittingSize)
+        XCTAssertGreaterThan(host.fittingSize.height, 80)
+        guard let path = ProcessInfo.processInfo.environment["CLICKY_PROMPT_SHOT"] else { return }
+        let window = NSWindow(contentRect: CGRect(x: -3000, y: -3000, width: host.frame.width + 40, height: host.frame.height + 40),
+                              styleMask: [.borderless], backing: .buffered, defer: false)
+        window.isReleasedWhenClosed = false
+        window.backgroundColor = NSColor(white: 0.18, alpha: 1)
+        let container = NSView(frame: CGRect(origin: .zero, size: window.frame.size))
+        host.frame.origin = CGPoint(x: 20, y: 20)
+        container.addSubview(host)
+        window.contentView = container
+        window.orderFront(nil)
+        defer { window.close() }
+        container.layoutSubtreeIfNeeded()
+        let rep = try XCTUnwrap(container.bitmapImageRepForCachingDisplay(in: container.bounds))
+        container.cacheDisplay(in: container.bounds, to: rep)
+        try XCTUnwrap(rep.representation(using: .png, properties: [:])).write(to: URL(fileURLWithPath: path))
+    }
+
+    /// Renders the settings card with this Mac's real outputs: `CLICKY_OUTPUT_CARD_SHOT=<png path>`.
+    @MainActor
+    func testTheOutputCardRendersTheDevicesAndARule() throws {
+        guard let path = ProcessInfo.processInfo.environment["CLICKY_OUTPUT_CARD_SHOT"] else { return }
+        let suite = "dev.genesis.clicky.output.\(UUID().uuidString)"
+        let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
+        defer { defaults.removePersistentDomain(forName: suite) }
+        let appearance = NativeSettingsAppearance(defaults: defaults, notificationNamespace: suite, observeExternalChanges: false)
+        let model = ClickyModel(defaults: defaults, appearance: appearance, observeSystemEvents: false)
+        model.refreshOutput()
+        if let system = model.output?.system,
+           let faster = AudioOutputs.suggestion(instead: system, outputs: model.outputs, limit: .infinity) {
+            model.setRule(when: system, playOn: faster)
+        }
+        let view = ClickyOutputCard(model: model).padding(24)
+            .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .top)
+            .background(NativeThemePalette.graphiteBase)
+            .environment(\.nativeSettingsTheme, .graphite)
+            .environment(\.colorScheme, .dark)
+        let rep = try KitShots.render(view, size: CGSize(width: 680, height: 560), name: "clicky-output-card", settle: 0.6)
+        try XCTUnwrap(rep.representation(using: .png, properties: [:])).write(to: URL(fileURLWithPath: path))
+    }
+}
diff --git a/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyStatsPagesTests.swift b/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyStatsPagesTests.swift
new file mode 100644
index 0000000000..c64a8139c9
--- /dev/null
+++ b/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyStatsPagesTests.swift
@@ -0,0 +1,375 @@
+import AppKit
+import SwiftUI
+import XCTest
+
+@testable import GenesisKitBase
+@testable import GenesisKit
+
+/// The Stats and Performance pages: ranges, comparisons, the dictation estimate, calendar bins and pictures of both
+/// pages with the sample data.
+@MainActor
+final class ClickyStatsPagesTests: XCTestCase {
+    private func calendar(firstWeekday: Int = 2) -> Calendar {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(identifier: "Europe/Prague")!
+        calendar.locale = Locale(identifier: "en_US")
+        calendar.firstWeekday = firstWeekday
+        return calendar
+    }
+
+    private func date(_ text: String) -> Date { ISO8601DateFormatter().date(from: text)! }
+
+    func testDictationEstimateAppliesTheDictatedShareToBothSidesAndAddsReview() {
+        var totals = ClickyPerformanceBucket()
+        totals.characters = 750; totals.corrections = 50; totals.activeSeconds = 180; totals.sessions = 2
+        let estimate = ClickyDictationEstimate(totals: totals, wordsPerMinute: 140, setupPerSession: 3,
+            dictatedShare: 0.7, reviewShare: 0.15)
+        XCTAssertEqual(estimate.retainedWords, 98, accuracy: 0.0001)
+        XCTAssertEqual(estimate.typingSeconds, 126, accuracy: 0.0001)
+        XCTAssertEqual(estimate.speakingSeconds, 42, accuracy: 0.0001)
+        XCTAssertEqual(estimate.setupSeconds, 4.2, accuracy: 0.0001)
+        XCTAssertEqual(estimate.reviewSeconds, 6.3, accuracy: 0.0001)
+        XCTAssertEqual(estimate.differenceSeconds, 126 - 52.5, accuracy: 0.0001)
+        let none = ClickyDictationEstimate(totals: totals, wordsPerMinute: 140, setupPerSession: 3, dictatedShare: 0)
+        XCTAssertEqual(none.differenceSeconds, 0, "0% dictated compares nothing")
+    }
+
+    func testRangesPreviousPeriodsAndCoverage() {
+        let calendar = calendar()
+        let now = date("2026-10-25T14:30:00Z")
+        let week = ClickyRanges.interval(ClickyRanges.week, now: now, earliest: nil, calendar: calendar)
+        XCTAssertEqual(ClickyRanges.dayCount(week, calendar: calendar), 7)
+        let previous = ClickyRanges.previous(week, range: ClickyRanges.week, calendar: calendar)!
+        XCTAssertEqual(ClickyRanges.dayCount(previous, calendar: calendar), 7)
+        XCTAssertEqual(previous.end, calendar.date(byAdding: .day, value: -7, to: now))
+        let today = ClickyRanges.interval(ClickyRanges.today, now: now, earliest: nil, calendar: calendar)
+        let yesterday = ClickyRanges.previous(today, range: ClickyRanges.today, calendar: calendar)!
+        XCTAssertEqual(yesterday.duration, today.duration, accuracy: 3600, "yesterday until the same time")
+        XCTAssertNil(ClickyRanges.previous(today, range: ClickyRanges.all, calendar: calendar))
+        let started = calendar.date(byAdding: .day, value: -2, to: now)!
+        let year = ClickyRanges.interval(ClickyRanges.year, now: now, earliest: started, calendar: calendar)
+        XCTAssertEqual(ClickyRanges.coverageText(year, earliest: started, calendar: calendar),
+            "Recorded data covers 3 of the 366 days in this range.")
+        XCTAssertNil(ClickyRanges.coverageText(today, earliest: started, calendar: calendar))
+        XCTAssertEqual(ClickyRanges.groupings(for: year, now: now).map(\.rawValue), [3600, 86400, 604800],
+            "no minute grouping past the 30 days of minute detail")
+        XCTAssertEqual(ClickyRanges.grouping(for: ClickyRanges.custom, span: 86400), .fifteenMinutes)
+        XCTAssertEqual(ClickyRanges.grouping(for: ClickyRanges.custom, span: 120 * 86400), .day)
+    }
+
+    func testWeekBinsStartOnTheCalendarsFirstWeekday() {
+        let monday = calendar(firstWeekday: 2)
+        let points = [
+            NativeTimePoint(date: date("2026-10-21T10:00:00Z"), value: 2),  // Wednesday
+            NativeTimePoint(date: date("2026-10-25T10:00:00Z"), value: 3),  // Sunday
+        ]
+        let start = date("2026-10-01T00:00:00Z")
+        let end = date("2026-10-25T20:00:00Z")
+        let mondayBins = NativeChartSampling.bins(points: points, start: start, end: end, step: 604800, calendar: monday)
+        XCTAssertEqual(mondayBins.map(\.value), [5])
+        XCTAssertEqual(monday.component(.weekday, from: mondayBins[0].date), 2, "the week bar is dated on Monday")
+        let sunday = calendar(firstWeekday: 1)
+        let sundayBins = NativeChartSampling.bins(points: points, start: start, end: end, step: 604800, calendar: sunday)
+        XCTAssertEqual(sundayBins.map(\.value), [2, 3], "a Sunday-first calendar starts a new week on Sunday")
+        let span = NativeChartSampling.spanText(mondayBins[0].date, step: 604800, calendar: monday)
+        let sundayText = monday.date(byAdding: .day, value: 6, to: mondayBins[0].date)!
+            .formatted(.dateTime.weekday(.abbreviated).month(.abbreviated).day())
+        XCTAssertTrue(span.hasSuffix(" to \(sundayText)"), "a week bar names its whole span: \(span)")
+    }
+
+    func testZoomFractionIsFiniteWithNoZoomRangeAndClampsNormalRanges() {
+        XCTAssertEqual(NativeChartSampling.zoomFraction(1, minimum: 1, maximum: 1), 0)
+        XCTAssertEqual(NativeChartSampling.zoomFraction(2, minimum: 1, maximum: 4), 0.5, accuracy: 0.0001)
+        XCTAssertEqual(NativeChartSampling.zoomFraction(8, minimum: 1, maximum: 4), 1)
+        XCTAssertEqual(NativeChartSampling.zoomFraction(0.5, minimum: 1, maximum: 4), 0)
+    }
+
+    func testFittedDomainIncludesTheFirstPartialWeek() {
+        let calendar = calendar()
+        let start = date("2026-10-21T10:00:00Z")
+        let end = date("2026-12-25T10:00:00Z")
+        var stats = ClickyStatistics()
+        stats.record(keyCode: 0, release: false, at: start, calendar: calendar)
+        let report = ClickyPerformanceReport(statistics: stats,
+            filter: ClickyPerformanceFilter(start: start, end: end), grouping: .week, calendar: calendar)
+        let first = report.timeline.first!.date
+        XCTAssertLessThan(first, start)
+        XCTAssertEqual(NativeChartSampling.fittedStart(start, firstPoint: first), first)
+        let points = report.timeline.map { NativeTimePoint(date: $0.date, value: Double($0.totals.presses)) }
+        let bins = NativeChartSampling.bins(points: points,
+            start: NativeChartSampling.fittedStart(start, firstPoint: first), end: end, step: 604800, calendar: calendar)
+        XCTAssertEqual(bins.reduce(0) { $0 + $1.value }, Double(report.total.presses))
+        XCTAssertEqual(NativeChartSampling.fittedStart(start, firstPoint: nil), start)
+    }
+
+    func testComparisonUsesMinutesOnBothSidesOfPartialHourBoundaries() {
+        let calendar = calendar()
+        let now = date("2026-10-25T14:05:00Z")
+        let start = calendar.startOfDay(for: now)
+        let interval = DateInterval(start: start, end: now)
+        let previous = ClickyRanges.previous(interval, range: ClickyRanges.today, calendar: calendar)!
+        let cutoff = previous.end
+        var stats = ClickyStatistics()
+        for at in [cutoff.addingTimeInterval(-60), cutoff.addingTimeInterval(60), now.addingTimeInterval(-60)] {
+            stats.record(keyCode: 0, release: false, at: at, calendar: calendar)
+        }
+        let report = ClickyStatsReport(statistics: stats, interval: interval, previous: previous,
+            resolution: .minute, releases: false, now: now, calendar: calendar)
+        XCTAssertEqual(report.total, 1)
+        XCTAssertEqual(report.previousTotal, 1, "the later press is after yesterday's local-time cutoff, even across DST")
+        XCTAssertFalse(report.approximateTotals)
+
+        let partial = ClickyStatsReport(statistics: stats,
+            interval: DateInterval(start: cutoff, end: cutoff.addingTimeInterval(120)),
+            previous: nil, resolution: .minute, releases: false, now: now, calendar: calendar)
+        XCTAssertEqual(partial.total, 1, "the leading boundary excludes the earlier press")
+    }
+
+    func testComparisonDisclosesExpiredMinutePrecision() {
+        let calendar = calendar()
+        let now = date("2026-10-25T14:05:00Z")
+        let at = date("2026-08-24T14:04:00Z")
+        var stats = ClickyStatistics()
+        stats.record(keyCode: 0, release: false, at: at, calendar: calendar)
+        stats.minutes = [:]
+        let report = ClickyStatsReport(statistics: stats,
+            interval: DateInterval(start: calendar.startOfDay(for: at), end: at.addingTimeInterval(60)),
+            previous: nil, resolution: .hour, releases: false, now: now, calendar: calendar)
+        XCTAssertEqual(report.total, 1)
+        XCTAssertTrue(report.approximateTotals)
+    }
+
+    func testAverageBinsLeaveEmptySlotsOutAndDoNotAddRates() {
+        let points = [
+            NativeTimePoint(date: Date(timeIntervalSince1970: 0), value: 40),
+            NativeTimePoint(date: Date(timeIntervalSince1970: 60), value: 60),
+            NativeTimePoint(date: Date(timeIntervalSince1970: 600), value: 50),
+        ]
+        let bins = NativeChartSampling.bins(points: points, start: Date(timeIntervalSince1970: 0),
+            end: Date(timeIntervalSince1970: 1200), step: 300, combine: .average)
+        XCTAssertEqual(bins.map(\.value), [50, 50])
+        XCTAssertEqual(bins.map(\.date.timeIntervalSince1970), [0, 600])
+    }
+
+    func testMergedPerformanceRatesUseTheirUnequalDenominators() {
+        let start = date("2026-10-19T10:00:00Z")
+        let end = start.addingTimeInterval(300)
+        let pace = [NativeTimePoint(date: start, value: 100, weight: 30),
+            NativeTimePoint(date: start.addingTimeInterval(60), value: 20, weight: 300)]
+        let paceBins = NativeChartSampling.bins(points: pace, start: start, end: end, step: 300, combine: .average)
+        XCTAssertEqual(paceBins.first!.value, (100 * 30 + 20 * 300) / 330.0, accuracy: 0.000001)
+        XCTAssertEqual(paceBins.first!.weight, 330)
+        let corrections = [NativeTimePoint(date: start, value: 10, weight: 20),
+            NativeTimePoint(date: start.addingTimeInterval(60), value: 50, weight: 180)]
+        let correctionBins = NativeChartSampling.bins(points: corrections, start: start, end: end, step: 300, combine: .average)
+        XCTAssertEqual(correctionBins.first!.value, 46, accuracy: 0.000001)
+        let sums = NativeChartSampling.bins(points: pace, start: start, end: end, step: 300)
+        XCTAssertEqual(sums.first!.value, 120, "event sums ignore the rate weights")
+    }
+
+    func testCalendarRateBinsKeepWeightsForFurtherMerging() {
+        let calendar = calendar()
+        let start = date("2026-10-19T10:00:00Z")
+        let end = date("2026-10-23T10:00:00Z")
+        let points = [NativeTimePoint(date: start, value: 10, weight: 2),
+            NativeTimePoint(date: start.addingTimeInterval(86400), value: 30, weight: 8)]
+        let bins = NativeChartSampling.bins(points: points, start: start, end: end,
+            step: 604800, calendar: calendar, combine: .average)
+        XCTAssertEqual(bins.first!.value, 26, accuracy: 0.000001)
+        XCTAssertEqual(bins.first!.weight, 10)
+        let merged = NativeChartSampling.bins(points: bins + [NativeTimePoint(date: start.addingTimeInterval(172800), value: 50, weight: 10)],
+            start: bins.first!.date, end: end, step: 604800, calendar: calendar, combine: .average)
+        XCTAssertEqual(merged.first!.value, 38, accuracy: 0.000001)
+        XCTAssertEqual(merged.first!.weight, 20)
+    }
+
+    func testCustomDatesSurviveRecreatingThePerformancePage() {
+        let saved = defaults(["clicky.performance.range": ClickyRanges.custom])
+        let store = ClickyAnalyticsStore()
+        let first = ClickyPerformanceView(store: store, defaults: saved)
+        let start = date("2026-04-01T10:00:00Z")
+        let end = date("2026-04-17T10:00:00Z")
+        first.start = start
+        first.end = end
+        let reopened = ClickyPerformanceView(store: store, defaults: saved)
+        XCTAssertEqual(reopened.start, start)
+        XCTAssertEqual(reopened.end, end)
+        XCTAssertEqual(saved.string(forKey: "clicky.performance.range"), ClickyRanges.custom)
+        XCTAssertEqual(saved.double(forKey: "clicky.performance.customStart"), start.timeIntervalSince1970)
+        XCTAssertEqual(saved.double(forKey: "clicky.performance.customEnd"), end.timeIntervalSince1970)
+    }
+
+    func testRecordsFindTheBusiestDayAndStreaks() {
+        let calendar = calendar()
+        let today = calendar.startOfDay(for: date("2026-10-25T10:00:00Z"))
+        func day(_ offset: Int) -> Date { calendar.date(byAdding: .day, value: offset, to: today)! }
+        let records = ClickyRecords(days: [day(-9): 5, day(-8): 50, day(-7): 5, day(-6): 5, day(-3): 0, day(-1): 1, day(0): 2],
+            today: today, calendar: calendar)
+        XCTAssertEqual(records.busiestDay, day(-8))
+        XCTAssertEqual(records.longestStreak, 4)
+        XCTAssertEqual(records.currentStreak, 2)
+    }
+
+    func testStatsReportTotalsComparesAndOrdersWeekdays() {
+        let calendar = calendar(firstWeekday: 1)
+        var stats = ClickyStatistics()
+        let now = date("2026-10-25T14:30:00Z")
+        for offset in (0..<10).reversed() {
+            let at = calendar.date(byAdding: .day, value: -offset, to: now)!.addingTimeInterval(-3600)
+            for _ in 0..<(offset + 1) { stats.record(keyCode: 0, release: false, at: at, calendar: calendar) }
+        }
+        let week = ClickyRanges.interval(ClickyRanges.week, now: now, earliest: stats.historyStartedAt, calendar: calendar)
+        let report = ClickyStatsReport(statistics: stats, interval: week,
+            previous: ClickyRanges.previous(week, range: ClickyRanges.week, calendar: calendar),
+            resolution: .hour, releases: false, now: now, calendar: calendar)
+        XCTAssertEqual(report.total, (1...7).reduce(0, +))
+        XCTAssertEqual(report.previousTotal, 8 + 9 + 10)
+        XCTAssertEqual(report.activeDays, 7)
+        XCTAssertEqual(report.records.currentStreak, 7)
+        XCTAssertEqual(report.heatmap.count, 7 * 24)
+        XCTAssertEqual(ClickyWeekdays.order(calendar).first, 6, "a Sunday-first calendar lists Sunday first")
+        let sundayRow = report.heatmap.filter { $0.row == 0 }.reduce(0) { $0 + $1.value }
+        XCTAssertEqual(sundayRow, 1, "today is a Sunday with one press")
+    }
+
+    func testReleaseChartKeepsPressSummaryAndDailyRhythm() {
+        let calendar = calendar()
+        let now = date("2026-10-25T14:30:00Z")
+        var stats = ClickyStatistics()
+        stats.record(keyCode: 0, release: false, at: now.addingTimeInterval(-86400), calendar: calendar)
+        stats.record(keyCode: 0, release: true, at: now.addingTimeInterval(-60), calendar: calendar)
+        let interval = ClickyRanges.interval(ClickyRanges.week, now: now, earliest: stats.historyStartedAt, calendar: calendar)
+        let report = ClickyStatsReport(statistics: stats, interval: interval, previous: nil,
+            resolution: .minute, releases: true, now: now, calendar: calendar)
+        XCTAssertEqual(report.total, 1)
+        XCTAssertEqual(report.records.busiestDay, calendar.startOfDay(for: now.addingTimeInterval(-86400)))
+        XCTAssertEqual(report.dayTimeline.reduce(0) { $0 + $1.value }, 1)
+        XCTAssertEqual(report.dayTimeline.first { $0.date == calendar.startOfDay(for: now) }?.value, 0)
+        XCTAssertEqual(report.timeline.reduce(0) { $0 + $1.value }, 1, "the Activity chart still shows releases")
+    }
+
+    func testStatsResolutionsRespectBothRetentionTiers() {
+        let now = date("2026-10-25T14:30:00Z")
+        func available(_ days: Double) -> [ClickyTimeResolution] {
+            ClickyRanges.resolutions(for: DateInterval(start: now.addingTimeInterval(-days * 86400), end: now), now: now)
+        }
+        XCTAssertEqual(available(7), [.minute, .hour, .day])
+        XCTAssertEqual(available(90), [.hour, .day])
+        XCTAssertEqual(available(730), [.day], "a two-year hourly chart would silently omit its first year")
+    }
+
+    func testCustomGroupingClampsRestoredAndChangedChoicesToRetention() {
+        let now = date("2026-10-25T14:30:00Z")
+        let oldStart = now.addingTimeInterval(-180 * 86400)
+        let oldDay = DateInterval(start: oldStart, end: oldStart.addingTimeInterval(86400))
+        let suggested = ClickyRanges.grouping(for: ClickyRanges.custom, span: oldDay.duration)
+        XCTAssertEqual(suggested, .fifteenMinutes)
+        XCTAssertEqual(ClickyRanges.validGrouping(suggested, for: oldDay, now: now), .hour)
+        XCTAssertEqual(ClickyRanges.validGrouping(.week, for: oldDay, now: now), .week)
+        let recentDay = DateInterval(start: now.addingTimeInterval(-86400), end: now)
+        XCTAssertEqual(ClickyRanges.validGrouping(suggested, for: recentDay, now: now), .fifteenMinutes)
+        for preferred in ClickyPerformanceGrouping.allCases {
+            XCTAssertTrue(ClickyRanges.groupings(for: oldDay, now: now)
+                .contains(ClickyRanges.validGrouping(preferred, for: oldDay, now: now)))
+        }
+    }
+
+    func testRetainedCoverageDoesNotCountExpiredYearsOrCustomDates() {
+        let calendar = calendar()
+        let now = date("2026-10-25T14:30:00Z")
+        let original = calendar.date(byAdding: .year, value: -3, to: now)!
+        var stats = ClickyStatistics()
+        stats.record(keyCode: 0, release: false, at: original, calendar: calendar)
+        stats.record(keyCode: 0, release: false, at: now.addingTimeInterval(-60), calendar: calendar)
+        let history = ClickyRetention.historyStart(stats, now: now, calendar: calendar)!
+        let performance = ClickyRetention.performanceStart(stats, now: now)!
+        XCTAssertEqual(history, calendar.date(byAdding: .day, value: -729, to: calendar.startOfDay(for: now)))
+        XCTAssertEqual(performance.timeIntervalSince1970, floor(now.timeIntervalSince1970 / 3600) * 3600 - 730 * 86400)
+        XCTAssertEqual(stats.historyStartedAt, original, "the history-since label keeps the original date")
+        XCTAssertEqual(stats.performanceStartedAt, original)
+        let all = ClickyRanges.interval(ClickyRanges.all, now: now, earliest: history, calendar: calendar)
+        let report = ClickyStatsReport(statistics: stats, interval: all, previous: nil,
+            resolution: .day, releases: false, now: now, calendar: calendar)
+        XCTAssertEqual(report.coveredDays, 730)
+        XCTAssertEqual(report.total, 1)
+        XCTAssertEqual(report.dailyAverage, 1.0 / 730, accuracy: 0.000001)
+        let expired = DateInterval(start: original, end: original.addingTimeInterval(86400))
+        XCTAssertEqual(ClickyRanges.coveredDays(expired, earliest: history, calendar: calendar), 0)
+        XCTAssertEqual(ClickyRanges.coveredDays(expired, earliest: performance, calendar: calendar), 0)
+        XCTAssertEqual(ClickyRanges.coverageText(expired, earliest: performance, calendar: calendar),
+            "Nothing was recorded in this range yet.")
+    }
+
+    func testRetainedCoverageFallsBackToBucketsWithoutLegacyTimestamps() {
+        let calendar = calendar()
+        let now = date("2026-10-25T14:30:00Z")
+        var stats = ClickyStatistics()
+        XCTAssertNil(ClickyRetention.historyStart(stats, now: now, calendar: calendar))
+        XCTAssertNil(ClickyRetention.performanceStart(stats, now: now))
+        let day = calendar.startOfDay(for: now.addingTimeInterval(-86400))
+        stats.days[Int(day.timeIntervalSince1970)] = ClickyActivityBucket(presses: 1)
+        stats.performanceMinutes[Int(day.timeIntervalSince1970 / 60)] = ClickyPerformanceBucket()
+        XCTAssertEqual(ClickyRetention.historyStart(stats, now: now, calendar: calendar), day)
+        XCTAssertEqual(ClickyRetention.performanceStart(stats, now: now), day)
+    }
+
+    func testRecordingPauseReasonsFollowTheCollectionPolicy() {
+        XCTAssertEqual(ClickyRecordingStatus.pause(systemSleeping: true, takingBreak: true, quiet: true, excluded: true), .macSleeping)
+        XCTAssertEqual(ClickyRecordingStatus.pause(systemSleeping: false, takingBreak: true, quiet: true, excluded: true), .takingBreak)
+        XCTAssertEqual(ClickyRecordingStatus.pause(systemSleeping: false, takingBreak: false, quiet: true, excluded: true), .quietHours)
+        XCTAssertEqual(ClickyRecordingStatus.pause(systemSleeping: false, takingBreak: false, quiet: false, excluded: true), .excludedApplication)
+        XCTAssertNil(ClickyRecordingStatus.pause(systemSleeping: false, takingBreak: false, quiet: false, excluded: false))
+        for status in [ClickyRecordingStatus.takingBreak, .quietHours, .excludedApplication, .macSleeping] {
+            XCTAssertNotNil(status.message)
+        }
+        XCTAssertEqual(ClickyRecordingStatus.takingBreak.actionTitle, "Resume Clicky")
+        XCTAssertEqual(ClickyRecordingStatus.quietHours.actionTitle, "Turn Off Quiet Hours")
+        XCTAssertTrue(ClickyRecordingStatus.excludedApplication.actionTitle.isEmpty)
+        XCTAssertTrue(ClickyRecordingStatus.macSleeping.actionTitle.isEmpty)
+    }
+
+    func testRecordingStatusNamesTheReasonAndTheFix() {
+        XCTAssertNil(ClickyRecordingStatus.recording.message)
+        XCTAssertEqual(ClickyRecordingStatus.statisticsOff.actionTitle, "Turn On Statistics")
+        XCTAssertTrue(ClickyRecordingStatus.inputMonitoringMissing.message?.contains("Input Monitoring") == true)
+    }
+
+    // MARK: Pictures
+
+    private func page(_ content: some View) -> some View {
+        ScrollView { content.padding(24) }
+            .background(NativeThemePalette.graphiteBase)
+            .environment(\.nativeSettingsTheme, .graphite)
+            .environment(\.colorScheme, .dark)
+    }
+
+    private func defaults(_ values: [String: Any]) -> UserDefaults {
+        let name = "clicky.stats.shots.\(UUID().uuidString)"
+        let defaults = UserDefaults(suiteName: name)!
+        defaults.removePersistentDomain(forName: name)
+        for (key, value) in values { defaults.set(value, forKey: key) }
+        return defaults
+    }
+
+    func testPerformancePageRendersTheSampleData() throws {
+        let store = ClickyAnalyticsStore()
+        store.flush(ClickyStatistics.example(now: Date()))
+        for (range, name) in [("7 days", "clicky-performance-7days"), ("1 year", "clicky-performance-1year")] {
+            let view = page(ClickyPerformanceView(store: store, defaults: defaults(["clicky.performance.range": range]),
+                status: .clickyOff, fixRecording: {}))
+            let rep = try KitShots.render(view, size: CGSize(width: 820, height: 3300), name: name, settle: 3)
+            XCTAssertGreaterThan(KitShots.brightness(rep, in: CGRect(x: 0, y: 0, width: 820, height: 600), viewWidth: 820), 0.02)
+        }
+    }
+
+    func testStatsPageRendersTheSampleData() throws {
+        let store = ClickyAnalyticsStore()
+        store.flush(ClickyStatistics.example(now: Date()))
+        for (range, tab, name) in [("30 days", "Activity", "clicky-stats-30days"), ("1 year", "Rhythm", "clicky-stats-1year-rhythm")] {
+            let view = page(ClickyAnalyticsView(store: store,
+                defaults: defaults(["clicky.stats.range": range, "clicky.stats.tab": tab])))
+            let rep = try KitShots.render(view, size: CGSize(width: 820, height: 1500), name: name, settle: 3)
+            XCTAssertGreaterThan(KitShots.brightness(rep, in: CGRect(x: 0, y: 0, width: 820, height: 600), viewWidth: 820), 0.02)
+        }
+    }
+}
diff --git a/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyTests.swift b/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyTests.swift
index e5fd375b13..a78128a066 100644
--- a/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyTests.swift
+++ b/src/macos/GenesisKit/Tests/GenesisKitTests/ClickyTests.swift
@@ -245,9 +245,11 @@ final class ClickyTests: XCTestCase {
     func testExampleStatisticsHaveConsistentTotalsAndRecentDataWithoutStorage() {
         let example = ClickyStatistics.example(now: date(23, 30), calendar: calendar)
         XCTAssertEqual(example.keys.values.reduce(0, +), example.presses)
-        XCTAssertEqual(example.minutes.values.reduce(0) { $0 + $1.presses }, example.presses)
-        XCTAssertEqual(example.hours.values.reduce(0) { $0 + $1.presses }, example.presses)
         XCTAssertEqual(example.days.values.reduce(0) { $0 + $1.presses }, example.presses)
+        let recentHours = example.hours.filter { $0.key >= example.minutes.keys.min()! / 60 }
+        XCTAssertEqual(example.minutes.values.reduce(0) { $0 + $1.presses }, recentHours.values.reduce(0) { $0 + $1.presses })
+        XCTAssertGreaterThan(example.days.count, 700, "the sample fills the long ranges")
+        XCTAssertGreaterThan(example.performanceHours.count, 5000)
         let recent = Int(date(23).timeIntervalSince1970 / 60)
         XCTAssertGreaterThan(example.minutes.filter { $0.key >= recent }.values.reduce(0) { $0 + $1.presses }, 0)
     }
@@ -1072,6 +1074,51 @@ final class ClickyTests: XCTestCase {
         XCTAssertEqual(try JSONDecoder().decode(ClickyPreferences.self, from: encoded), preferences)
     }
 
+    func testOutputChangeRestartSurvivesAnotherClickDuringStart() {
+        var state = ClickyAudioStartState()
+        state.requestClick()
+        state.outputChanged()
+        state.requestStop()
+        state.requestClick()
+        state.requestClick()
+        XCTAssertEqual(state.complete(), .restart, "clicks cannot cancel a mandatory output restart")
+        state.requestClick()
+        XCTAssertEqual(state.complete(), .play, "the next start applies the new output once")
+
+        state.requestStop()
+        state.requestClick()
+        XCTAssertEqual(state.complete(), .play, "a click still cancels an ordinary idle stop")
+        state.outputChanged()
+        state.requestStop()
+        XCTAssertEqual(state.complete(), .stop, "an explicit stop with no later click stays stopped")
+        state.requestClick()
+        XCTAssertEqual(state.complete(), .play, "a later fresh start can play on the already-updated output")
+    }
+
+    @MainActor
+    func testRecordingBannerResumesBreakAndCanDisableQuietHours() {
+        let monitor = InputMonitorStub()
+        monitor.granted = true
+        let (model, defaults, suite) = monitorFixture(monitor)
+        defer { model.shutdown(); disposeIntegrationDefaults(defaults, suite: suite) }
+        model.activate()
+        XCTAssertEqual(model.recordingStatus, .recording)
+        model.snooze(minutes: 15)
+        XCTAssertEqual(model.recordingStatus, .takingBreak)
+        model.fixRecording()
+        XCTAssertEqual(model.recordingStatus, .recording)
+        XCTAssertNil(model.sleepingUntil)
+        let parts = Calendar.current.dateComponents([.hour, .minute], from: Date())
+        let minute = (parts.hour ?? 0) * 60 + (parts.minute ?? 0)
+        model.preferences.quietStart = (minute + 1080) % 1440
+        model.preferences.quietEnd = (minute + 360) % 1440
+        model.preferences.quietHours = true
+        XCTAssertEqual(model.recordingStatus, .quietHours)
+        model.fixRecording()
+        XCTAssertFalse(model.preferences.quietHours)
+        XCTAssertEqual(model.recordingStatus, .recording)
+    }
+
     @MainActor
     func testPreviewCannotActivateInputAndStartsOff() {
         let suite = "dev.genesis.clicky.test.\(UUID().uuidString)"
@@ -2376,15 +2423,94 @@ extension ClickyTests {
 
     func testDictationEstimateUsesRetainedWordConventionAndCanFavorTyping() {
         var totals = ClickyPerformanceBucket()
-        totals.characters = 750; totals.corrections = 50; totals.activeSeconds = 180; totals.bursts = 2
-        let estimate = ClickyDictationEstimate(totals: totals, wordsPerMinute: 140, setupPerBurst: 3)
+        totals.characters = 750; totals.corrections = 50; totals.activeSeconds = 180; totals.bursts = 9; totals.sessions = 2
+        let estimate = ClickyDictationEstimate(totals: totals, wordsPerMinute: 140, setupPerSession: 3)
         XCTAssertEqual(totals.estimatedWords, 150)
         XCTAssertEqual(totals.estimatedRetainedWords, 140)
         XCTAssertEqual(estimate.speakingSeconds, 60)
         XCTAssertEqual(estimate.setupSeconds, 6)
         XCTAssertEqual(estimate.differenceSeconds, 114)
         totals.activeSeconds = 20
-        XCTAssertEqual(ClickyDictationEstimate(totals: totals, wordsPerMinute: 140, setupPerBurst: 3).differenceSeconds, -46)
+        XCTAssertEqual(ClickyDictationEstimate(totals: totals, wordsPerMinute: 140, setupPerSession: 3).differenceSeconds, -46)
+    }
+
+    /// A session starts after a minute without text; minutes past 30 days roll into hours that the long ranges still count.
+    func testOldMinutesRollIntoHoursAndLongRangesCountThemOnce() {
+        var stats = ClickyStatistics()
+        func put(_ minute: Int, characters: Int, seconds: Double) {
+            var bucket = ClickyPerformanceBucket()
+            bucket.presses = characters; bucket.characters = characters; bucket.activeSeconds = seconds; bucket.bursts = 1
+            stats.performanceMinutes[minute] = bucket
+        }
+        let base = 29_000_000 // a whole hour: 483,333 h 20 min, so use an hour-aligned start below
+        let hourStart = (base / 60) * 60
+        put(hourStart, characters: 50, seconds: 20)      // starts a session
+        put(hourStart + 1, characters: 40, seconds: 15)  // same session
+        put(hourStart + 5, characters: 30, seconds: 10)  // a new session after 3 empty minutes
+        let recent = hourStart + 40 * 24 * 60
+        put(recent, characters: 25, seconds: 9)
+        stats.rollUpPerformance(olderThan: recent - 30 * 24 * 60)
+        XCTAssertEqual(stats.performanceMinutes.keys.sorted(), [recent], "only minutes inside 30 days stay")
+        let hour = stats.performanceHours[hourStart / 60]
+        XCTAssertEqual(hour?.characters, 120)
+        XCTAssertEqual(hour?.sessions, 2)
+        let all = ClickyPerformanceFilter(start: Date(timeIntervalSince1970: 0), end: Date(timeIntervalSince1970: Double(recent + 60) * 60))
+        let report = ClickyPerformanceReport(statistics: stats, filter: all, grouping: .week, calendar: calendar)
+        XCTAssertEqual(report.total.characters, 145, "hours and minutes are disjoint")
+        XCTAssertEqual(report.total.sessions, 3, "two rolled-up sessions and the recent minute's own")
+        XCTAssertEqual(report.total.activeSeconds, 54, accuracy: 0.001)
+    }
+
+    func testHourlyPerformanceExpiresFromRecordingTimeEvenWithoutOldMinutes() {
+        var stats = ClickyStatistics()
+        let nowMinute = 30_000_000
+        let oldestHour = nowMinute / 60 - 730 * 24
+        var bucket = ClickyPerformanceBucket()
+        bucket.characters = 5
+        stats.performanceHours = [oldestHour - 1: bucket, oldestHour: bucket]
+        stats.performanceMinutes[nowMinute] = bucket
+        stats.rollUpPerformance(olderThan: nowMinute - 30 * 24 * 60)
+        XCTAssertEqual(stats.performanceHours.keys.sorted(), [oldestHour])
+        XCTAssertEqual(stats.performanceMinutes.keys.sorted(), [nowMinute])
+    }
+
+    func testSessionContinuitySurvivesRollingBoundaryAndReload() throws {
+        var stats = ClickyStatistics()
+        let horizon = 29_000_000
+        var bucket = ClickyPerformanceBucket()
+        bucket.characters = 5
+        for minute in (horizon - 1)...(horizon + 1) { stats.performanceMinutes[minute] = bucket }
+        let filter = ClickyPerformanceFilter(start: Date(timeIntervalSince1970: Double(horizon - 120) * 60),
+            end: Date(timeIntervalSince1970: Double(horizon + 120) * 60))
+        func sessions(_ statistics: ClickyStatistics) -> Int {
+            ClickyPerformanceReport(statistics: statistics, filter: filter, grouping: .hour, calendar: calendar).total.sessions
+        }
+        XCTAssertEqual(sessions(stats), 1)
+        stats.rollUpPerformance(olderThan: horizon)
+        XCTAssertEqual(sessions(stats), 1)
+        stats = try JSONDecoder().decode(ClickyStatistics.self, from: JSONEncoder().encode(stats))
+        XCTAssertEqual(sessions(stats), 1, "the boundary survives saving and loading")
+        stats.rollUpPerformance(olderThan: horizon + 1)
+        XCTAssertEqual(sessions(stats), 1)
+        stats.rollUpPerformance(olderThan: horizon + 2)
+        XCTAssertEqual(sessions(stats), 1, "advancing the cutoff never invents another setup")
+    }
+
+    func testEachRangeOpensWithAGroupingThatKeepsTheTimelineReadable() {
+        XCTAssertEqual(ClickyPerformanceView.grouping(for: "Today"), .fifteenMinutes)
+        XCTAssertEqual(ClickyPerformanceView.grouping(for: "7 days"), .hour)
+        XCTAssertEqual(ClickyPerformanceView.grouping(for: "90 days"), .day)
+        XCTAssertEqual(ClickyPerformanceView.grouping(for: "All kept data"), .week)
+        XCTAssertEqual(ClickyRanges.known("All time", allowed: ClickyPerformanceView.ranges), "All kept data",
+            "a range saved under the old name still opens")
+        XCTAssertTrue(ClickyPerformanceView.ranges.contains("1 year"))
+    }
+
+    func testABucketSavedBeforeSessionsLoads() throws {
+        let old = #"{"presses":3,"characters":2,"corrections":0,"activeSeconds":1.5,"bursts":1,"carriedBurst":false}"#
+        let bucket = try JSONDecoder().decode(ClickyPerformanceBucket.self, from: Data(old.utf8))
+        XCTAssertEqual(bucket.characters, 2)
+        XCTAssertEqual(bucket.sessions, 0)
     }
 
     func testPreparedPerformanceReportPreservesTotalsAndRejectsCancellation() async {
diff --git a/src/macos/GenesisTools/Sources/Parts/Clicky/ClickyHost.swift b/src/macos/GenesisTools/Sources/Parts/Clicky/ClickyHost.swift
index e86bc1c706..2ce6f78990 100644
--- a/src/macos/GenesisTools/Sources/Parts/Clicky/ClickyHost.swift
+++ b/src/macos/GenesisTools/Sources/Parts/Clicky/ClickyHost.swift
@@ -53,11 +53,12 @@ final class ClickyHost: NSObject {
         guard let button = item?.button else { return }
         let popover = NSPopover()
         popover.behavior = .transient
-        popover.contentViewController = NSHostingController(
+        let controller = NSHostingController(
             rootView: ClickyPopoverView(
                 model: model,
+                // Clicky's own first page: with no page the window reopened wherever it was last (Widgets → Providers).
                 showSettings: { [weak self] in
-                    self?.showSettings()
+                    self?.showSettings(pageID: ClickySettingsPages.pageID(.sound))
                 },
                 quit: { [weak self] in
                     guard let self else { return }
@@ -65,6 +66,11 @@ final class ClickyHost: NSObject {
                     self.stop()
                     if shouldQuit { NSApp.terminate(nil) }
                 }))
+        // Sized before it shows: a popover that only learns its height after `show` grew upward past the top of the
+        // display, over the menu bar, so its first 200 pt could not be seen (Martin, 2026-10-25).
+        controller.sizingOptions = [.preferredContentSize]
+        popover.contentSize = controller.view.fittingSize
+        popover.contentViewController = controller
         self.popover = popover
         popover.show(relativeTo: button.bounds, of: button, preferredEdge: .minY)
     }