Add clock-aligned waterfall time markers (#5538)

## Summary

Closes #5537.

Right-click the panadapter or waterfall and choose **Waterfall Time
Markers** to display thin horizontal lines with small UTC timestamps at
the left edge. Intervals are Off, 15/30 seconds, and 1/5/10/15 minutes.
Off remains the default, and the selection persists independently per
panadapter slot in the existing Display document.

Markers align to clock boundaries (for example, HH:mm:00 for one-minute
markers) and follow their captured signal rows through live scrolling,
paused history, and resize. Changing the waterfall rate affects future
row cadence; existing history retains its captured row spacing. GPU and
software rendering share timestamp geometry and a cached label atlas.
Dedicated theme tokens provide subdued pale gray-blue lines/text with a
dark label backing.

This is a client display feature with no radio protocol, TX, dependency,
or unrelated behavior changes. Final visual/UX acceptance is requested
from the maintainer. The minimum interval is intentionally 15 seconds to
limit clutter.

## Review follow-up (maintainer-requested)

Four review nits from #5538 are addressed in `Address review nits on
waterfall time markers`:

- **30-minute and 1-hour intervals retired.** Issue #5537 proposed nine
intervals, but `kWaterfallHistoryMs` caps retained history at 20 minutes
and
a screenful of waterfall is only ~11-19 s at typical rates — measured on
the
demo simulator at 230-410 rows and 40-47 ms/row. A 1-hour marker would
be on
screen roughly 0.4% of the time and a 30-minute one ~0.9%. The menu now
tops
out at 15 minutes. This is a deliberate deviation from the issue text,
agreed
with the maintainer. A value written by an earlier build fails closed to
Off
  through `validWaterfallMarkerInterval()`; the settings test pins that.
- **`waterfallTimeMarkerSeconds` Q_PROPERTY is now read-only.** Nothing
needs
to set the interval by reflection, and the `dss snapshot` field already
  carries it for reads.
- **The new `dss snapshot` fields are documented** in
`docs/automation-bridge.md` next to the sibling DSS fields, with the two
  assertions that make markers checkable from the bridge.
- **The `<=` clock-advance guard's overlap with the bucket comparison is
now
  a deliberate, commented choice**, and the zero-advance row is pinned
  directly in the geometry test.

Rebased onto current `main` (the only conflict was both sides appending
to
`AETHER_SETTINGS_CONSUMERS` in `tests/tests.cmake`) and the touchpoint
manifest
regenerated for current main.

Independently verified on **Linux** (`AETHER_GPU_SPECTRUM=ON`), the
platform the
original test plan did not cover, driving the demo simulator over the
automation
bridge: markers land exactly on clock boundaries, scroll at
`1000/msPerRow` px/s (measured 20.82 vs 21.09 expected), survive resize
(410→350→230 rows), history scrub, `sim
stallscope`/`dropslice`/`malformed`, and
disconnect/reconnect, and the interval persists across a process
restart.
Mutation testing killed 5 of 6 deliberate reversions of the geometry.

## Constitution principle honored

- Principle V: preference lives in the existing nested Display settings
document, without a new flat settings key.
- Principle IV: original Qt implementation; WSJT-X is a behavioral
reference only, with no proprietary binary-derived code.
- Principle XI: demonstrated via focused tests and native Demo
automation-bridge checks.

## Test plan

- [x] Native macOS ARM64 RelWithDebInfo build with the local toolchain
and RADE enabled; ARM64 executable verified and RNNoise x86 sources
absent from the build graph.
- [x] Four focused CTests passed: `waterfall_time_markers_test`,
`waterfall_time_marker_settings_test`, `waterfall_history_buffer_test`,
and `spectrum_preview_logic_test`.
- [x] Geometry tests cover all intervals, wrap, fractional scrolling,
paused rows, resize mapping, duplicate timestamps, missing timestamps,
gaps, backward clock movement, Off, and invalid values. Settings test
checks independent slots, sibling preservation, and reload.
- [x] Mutation checks: reversing fractional-scroll direction fails the
geometry checks; reverting clock-boundary labeling fails delayed-row
assertions for every interval.
- [x] Native Cocoa/Metal automation bridge using isolated settings,
DEMO-0001, and TX disabled: menu selections, live motion, paused
history, resize, themes, Off, and restart persistence. A retained marker
stayed at row 226 when the paused waterfall grew from 410 to 470 rows.
Corrected timestamps were asserted divisible by the selected 15000 ms
interval and rendered pixels inspected.
- [x] Theme seed, touchpoint manifest, test registration,
engine-boundary strict check, and whitespace checks passed. No increase
in the hardcoded-color ratchet.
- [ ] Windows/Linux GPU runtime verification and actual Flex/Kiwi
source-switching validation have not been performed. Software renderer
was syntax-checked but not exercised as a full runtime build.
- [ ] CI results pending the PR run.

New CTests are socket-free. Bridge proof is a separate manual Demo
session. No live-radio validation is claimed; reopening the earlier
testing profile briefly auto-connected to a saved FLEX, so that instance
was closed without transmit and the final handoff used the clean Demo
profile.

## Checklist

- [x] Commit is SSH-signed and locally verified.
- [x] No new flat-key AppSettings calls.
- [x] Clean-room code.
- [x] Theme token documentation and generated inventories updated;
CHANGELOG unchanged.
- [x] Local code review completed; identified packet-arrival timestamp
labeling corrected before this PR.

Prepared with Codex assistance. Meter smoothing and GHSA references are
not applicable to this display-only feature.

---------

Co-authored-by: Jeremy [KK7GWY] <kk7gwy@aethersdr.com>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: 3 people

CMakeLists.txt

@@ -1068,6 +1068,7 @@ set(GUI_SOURCES
     src/gui/PanadapterMessageOverlay.h
     src/gui/PanadapterRenderScheduler.cpp
     src/gui/SpectrumWidget.cpp
+    src/gui/SpectrumWidget_TimeMarkers.cpp
     src/gui/WaterfallHistoryBuffer.cpp
     src/gui/SpectrumOverlayMenu.cpp
     src/gui/SpectrumOverlayWheelGuard.cpp

docs/architecture/aetherd-touchpoints.md

@@ -142,7 +142,7 @@ Burndown manifest for the engine/UI decoupling ([RFC](../aetherd-headless-engine
 | `core/SystemInventory.h` | 1 | ui-support — Startup and support-bundle inventory of host CPU, SIMD and RAM capabilities. Process diagnostics, not radio state. | unconverted |
 | `core/TciServer.h` | 3 | mixed(flex) — TCI WebSocket server for WSJT-X et al: protocol surface is canonical radio state, but audio/IQ rides Flex DAX | unconverted |
 | `core/TgxlConnection.h` | 2 | peripheral(4o3a) — Direct TCP client for the 4O3A Tuner Genius XL (port 9010, relay/autotune), reverse-engineered from the 4O3A management app — a standalone accessory transport, not SmartSDR. Not radio-family wire; a peripheral accessory, NOT behind the IRadioBackend radio seam (reclassified from vendor(flex), #4087 follow-up). | unconverted |
-| `core/ThemeManager.h` | 146 | ui-support — Qt token-based theming singleton (colors/fonts/QSS, theme files, editor hooks) — pure client GUI plumbing, no radio state. | unconverted |
+| `core/ThemeManager.h` | 147 | ui-support — Qt token-based theming singleton (colors/fonts/QSS, theme files, editor hooks) — pure client GUI plumbing, no radio state. | unconverted |
 | `core/ThreadCpuRing.h` | 2 | ui-support — Short host-thread CPU history used by Runtime Monitor peak and sparkline presentation. Diagnostic UI support, not radio state. | unconverted |
 | `core/TimeFrameVoter.h` | 1 | universal — Shared AetherClock time-frame types plus confidence-weighted cross-frame bit voting over a sliding window. Map-agnostic pure DSP/logic — no Qt, no GUI, no vendor ties. | unconverted |
 | `core/TxKeyingMarker.h` | 6 | ui-support — QWidget property marker guarding TX-keying controls from the automation bridge; GUI-shell plumbing, no radio state. | unconverted |

docs/automation-bridge.md

@@ -3315,7 +3315,7 @@ Actions:
 
 | action | value | effect |
 |---|---|---|
-| `snapshot` | optional pan target | Read `live`, current center/bandwidth MHz, waterfall/DSS history row counts, visible DSS row count, the current front-row peak bin/min/max/span, localized plateau metrics (`dssVisibleFrontMinValueBins`, `dssVisibleFrontLongestFlatRunBins`, and visible maxima), and flat/non-flat visible-row counts. |
+| `snapshot` | optional pan target | Read `live`, current center/bandwidth MHz, waterfall/DSS history row counts, visible DSS row count, the current front-row peak bin/min/max/span, localized plateau metrics (`dssVisibleFrontMinValueBins`, `dssVisibleFrontLongestFlatRunBins`, and visible maxima), flat/non-flat visible-row counts, and the waterfall time-marker state (`waterfallTimeMarkerSeconds`, `waterfallTimeMarkers`). |
 | `reset` | `native` or `kiwi` | Clear the selected stream's current/history rows and make that stream active for subsequent injection. |
 | `inject` | `<count> <firstPeakBin> <stepBin> [native\|kiwi [rowLowMhz rowHighMhz]]` | Add synthetic rows with one strong peak per row. `count` is rejected if it exceeds the retained waterfall history capacity. Native injection adds one fallback-style waterfall/DSS row per input row; Kiwi injection drives `updateKiwiSdrWaterfallRow()`. Kiwi frame arguments override the source row's frequency span, so tests can cover partial-overlap rows. |
 | `scrollback` | `<offsetRows>` | Enter waterfall history mode and rebuild the 3D surface using the same offset. |
@@ -3329,6 +3329,32 @@ injected peak becomes visible. The total row counts are still returned, but the
 `*RowsAdded` fields are the deterministic assertion surface if live data is also
 arriving between bridge requests.
 
+### Waterfall time markers
+
+`dss snapshot` reports the clock-aligned waterfall time markers (#5537):
+
+| field | meaning |
+|---|---|
+| `waterfallTimeMarkerSeconds` | Selected interval for this pan slot, in seconds. `0` means Off (the default). Only `0`, `15`, `30`, `60`, `300`, `600` and `900` are valid; anything else fails closed to `0`. |
+| `waterfallTimeMarkers` | Markers currently inside the waterfall viewport, newest first. Each entry is `{"timestampMs", "y"}`: `timestampMs` is the **clock boundary** the marker labels (always an exact multiple of the interval, never the packet arrival time), and `y` is its offset in pixels from the top of the waterfall rect. |
+
+The interval is set from the panadapter context menu (**Waterfall Time
+Markers**) and persists per pan slot in the `Display` settings document. It is
+not settable over the bridge; seed `DisplaySettings` or use the menu.
+
+Markers are attached to the signal row that was captured when the boundary was
+crossed, so they scroll with the waterfall rather than with wall-clock time.
+Two useful assertions:
+
+- Every `timestampMs` is divisible by `waterfallTimeMarkerSeconds * 1000`.
+- A marker's `y` advances at `1000 / waterfallTimeScaleMsPerRow` pixels per
+  second while live, and holds still under `dss scrollback`.
+
+An empty array is normal: a screenful of waterfall is only
+`waterfallRows * waterfallTimeScaleMsPerRow` milliseconds deep (typically
+11-19 s), so intervals longer than that window have no marker on screen most
+of the time.
+
 To reproduce a low-coverage Kiwi row, read `centerMhz` and `bandwidthMhz` from
 `dss snapshot`, then inject a Kiwi source row whose span overlaps less than 5%
 of the current view. For example, with `viewHigh = centerMhz + bandwidthMhz/2`,

docs/theming/canonical-tokens.md

@@ -206,3 +206,12 @@ PSK Reporter dark-map luminance ramp. Both bundled themes use the same dark
 cartographic palette; selecting the light app theme does not turn an explicitly
 enabled dark map light. These tokens affect only basemap images, not data
 overlays, attribution, or window chrome.
+
+### Waterfall time markers
+
+`color.waterfall.timeMarker.foreground` is the pale gray-blue foreground for
+UTC row annotations. Lines use 55% of its opacity; timestamp text uses its full
+opacity. `color.waterfall.timeMarker.background` provides a compact translucent
+dark text backing. Both bundled themes retain the same colors because waterfall
+signal palettes do not invert when application chrome changes theme. These
+annotations are independent of RX/TX, warning, and selection colors.

resources/themes/default-dark.json

@@ -48,6 +48,8 @@
           "accent.warning": "{color.amber.500}",
           "accent.danger":  "{color.red.500}",
           "accent.success": "{color.green.500}",
+          "waterfall.timeMarker.foreground": "#c8d8e8",
+          "waterfall.timeMarker.background": "#dc0f0f1a",
           "waterfall.live":    "{color.red.500}",
           "waterfall.history": "{color.gray.500}",
           "tx.mox.border":       "#d08020",

resources/themes/default-light.json

@@ -49,6 +49,8 @@
           "accent.warning": "{color.amber.500}",
           "accent.danger":  "{color.red.500}",
           "accent.success": "{color.green.500}",
+          "waterfall.timeMarker.foreground": "#c8d8e8",
+          "waterfall.timeMarker.background": "#dc0f0f1a",
           "waterfall.live":    "{color.red.500}",
           "waterfall.history": "{color.gray.300}",
           "tx.mox.border":       "#d08020",

src/core/ThemeSeedGenerated.cpp

@@ -207,6 +207,8 @@ void ThemeManager::seedGeneratedDefaults()
     }
     m_tokens.insert("color.waterfall.history", QString("#506070"));
     m_tokens.insert("color.waterfall.live", QString("#ff4d4d"));
+    m_tokens.insert("color.waterfall.timeMarker.background", QString("#dc0f0f1a"));
+    m_tokens.insert("color.waterfall.timeMarker.foreground", QString("#c8d8e8"));
     {
         ThemeFont f;
         f.family = QStringLiteral("DSEG7 Modern");

src/gui/DisplaySettings.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "core/AppSettings.h"
+#include "WaterfallTimeMarkers.h"
 
 #include <QJsonDocument>
 #include <QJsonObject>
@@ -29,6 +30,28 @@ namespace AetherSDR {
 //     spelling migrated by the now-removed TitleBarSettings helper.
 class DisplaySettings {
 public:
+    static int waterfallTimeMarkerSeconds(int slot)
+    {
+        if (!isValidPanSlotIndex(slot)) {
+            return 0;
+        }
+        return validWaterfallMarkerInterval(readObj()
+            .value("waterfallTimeMarkers").toObject()
+            .value(QString::number(slot)).toInt(0));
+    }
+
+    static void setWaterfallTimeMarkerSeconds(int slot, int seconds)
+    {
+        if (!isValidPanSlotIndex(slot)) {
+            return;
+        }
+        QJsonObject document = readObj();
+        QJsonObject slotStates = document.value("waterfallTimeMarkers").toObject();
+        slotStates[QString::number(slot)] = validWaterfallMarkerInterval(seconds);
+        document["waterfallTimeMarkers"] = slotStates;
+        write(document);
+    }
+
     // Global panadapter marker overlay preference. Default False preserves the
     // waterfall as signal history unless the operator opts into the overlay.
     static bool extendedPassband()

src/gui/SpectrumWidget.cpp

@@ -38,6 +38,7 @@
 #include <QWheelEvent>
 #include <QNativeGestureEvent>
 #include <QMenu>
+#include <QActionGroup>
 #include <QToolTip>
 #include <QDialog>
 #include <QFormLayout>
@@ -1285,6 +1286,14 @@ QVariantMap SpectrumWidget::automationDssSnapshot() const
         static_cast<qulonglong>(m_frequencyRangeCommandCount);
     m[QStringLiteral("historyOffsetRows")] = m_wfHistoryOffsetRows;
     m[QStringLiteral("maxHistoryOffsetRows")] = maxWaterfallHistoryOffsetRows();
+    m[QStringLiteral("waterfallTimeMarkerSeconds")] = m_wfTimeMarkerSeconds;
+    QVariantList timeMarkers;
+    for (const WaterfallTimeMarker& marker : visibleWaterfallTimeMarkers(m_waterfall.height())) {
+        timeMarkers.append(QVariantMap{
+            {QStringLiteral("timestampMs"), marker.timestampMs},
+            {QStringLiteral("y"), marker.y}});
+    }
+    m[QStringLiteral("waterfallTimeMarkers")] = timeMarkers;
     m[QStringLiteral("waterfallRows")] = m_waterfall.height();
     m[QStringLiteral("waterfallWidth")] = m_waterfall.width();
     m[QStringLiteral("waterfallWriteRow")] = m_wfWriteRow;
@@ -2315,6 +2324,7 @@ SpectrumWidget::SpectrumWidget(QWidget* parent)
     // recolours as it is scrolled back in.
     connect(&ThemeManager::instance(), &ThemeManager::themeChanged,
             this, [this]() {
+        m_wfTimeMarkerAtlasDirty = true;
         rebuildWfStopsCacheFromTheme();
         recolorWaterfallViewport();
         markOverlayDirty();
@@ -2334,6 +2344,8 @@ SpectrumWidget::SpectrumWidget(QWidget* parent)
         "color.background.2",
         "color.background.3",
         "color.background.spectrum",
+        "color.waterfall.timeMarker.foreground",
+        "color.waterfall.timeMarker.background",
         "color.spectrum.trace",
         "color.spectrum.peakHold",
         "color.spectrum.average",
@@ -2490,6 +2502,8 @@ QString SpectrumWidget::settingsKey(const QString& base) const
 void SpectrumWidget::setPanIndex(int idx)
 {
     m_panIndex = idx;
+    m_wfTimeMarkerSeconds = DisplaySettings::waterfallTimeMarkerSeconds(idx);
+    update();
     // Let the overlay menu (the +RX/+TNF/Band/ANT/Display/Memory/DAX button
     // rail) key its persisted collapsed/expanded state to this slot.
     if (m_overlayMenu) {
@@ -2499,6 +2513,7 @@ void SpectrumWidget::setPanIndex(int idx)
 
 void SpectrumWidget::loadSettings()
 {
+    m_wfTimeMarkerSeconds = DisplaySettings::waterfallTimeMarkerSeconds(m_panIndex);
     auto& s = AppSettings::instance();
     // These four values are stored by the radio (including in profiles). Older
     // releases persisted a competing client copy and reasserted it after status
@@ -5409,7 +5424,12 @@ void SpectrumWidget::appendVisibleRow(const QRgb* rowData,
 
     QElapsedTimer timer;
     timer.start();
+    if (m_wfVisibleTimeRows.size() != h) {
+        m_wfVisibleTimeRows = QVector<WaterfallTimeRow>(h);
+    }
+    const qint64 previousMs = m_wfVisibleTimeRows[m_wfWriteRow].timestampMs;
     m_wfWriteRow = (m_wfWriteRow - 1 + h) % h;
+    m_wfVisibleTimeRows[m_wfWriteRow] = {m_wfIncomingTimestampMs, previousMs};
     auto* row = reinterpret_cast<QRgb*>(m_waterfall.bits() + m_wfWriteRow * m_waterfall.bytesPerLine());
     std::memcpy(row, rowData, m_waterfall.width() * sizeof(QRgb));
     if (m_waterfallSupplemental.size() != m_waterfall.size()) {
@@ -5464,6 +5484,7 @@ void SpectrumWidget::appendHistoryRow(const quint8* intensityData,
                                       double supplementalCenterMhz,
                                       double supplementalBandwidthMhz)
 {
+    m_wfIncomingTimestampMs = timestampMs;
     // A hidden Flex/Kiwi source keeps only its small viewport and 96-row live
     // DSS surface warm. Retained scrollback belongs to the visible source; it
     // is rebuilt from new rows after a source switch (#4081, #4083).
@@ -5935,6 +5956,7 @@ void SpectrumWidget::paintWaterfallRowsFromHistory(
         resetVisibleWaterfallFrequencyFrames(centerMhz, bandwidthMhz);
     }
 
+    m_wfVisibleTimeRows = QVector<WaterfallTimeRow>(height);
     const int w = m_waterfall.width();
     const bool haveFrames = m_wfHistoryRowCenterMhz.size()
         == m_waterfallHistory.capacityRows();
@@ -5965,6 +5987,10 @@ void SpectrumWidget::paintWaterfallRowsFromHistory(
 
         const int destinationRow =
             waterfallVisibleRowForAge(writeRowOrigin, age, height);
+        const int previousIndex = historyRowIndexForAge(m_wfHistoryOffsetRows + age + 1);
+        m_wfVisibleTimeRows[destinationRow] = {
+            m_wfHistoryTimestamps.value(rowIndex),
+            m_wfHistoryTimestamps.value(previousIndex)};
         auto* dst = reinterpret_cast<QRgb*>(
             m_waterfall.scanLine(destinationRow));
         // With no stamped frames the rows carry no capture information at all,
@@ -6103,6 +6129,7 @@ void SpectrumWidget::rebuildWaterfallViewportForFrame(double centerMhz,
         m_waterfallSupplemental.fill(Qt::black);
     }
     m_wfWriteRow = 0;
+    m_wfVisibleTimeRows = QVector<WaterfallTimeRow>(m_waterfall.height());
     resetVisibleWaterfallFrequencyFrames(centerMhz, bandwidthMhz);
     m_wfVisiblePaletteToken = waterfallPaletteToken();
 
@@ -6507,6 +6534,8 @@ void SpectrumWidget::clearDisplay()
 
 void SpectrumWidget::clearCurrentWaterfallRows()
 {
+    m_wfVisibleTimeRows = QVector<WaterfallTimeRow>(m_waterfall.height());
+    m_wfIncomingTimestampMs = 0;
     if (!m_waterfall.isNull()) {
         m_waterfall.fill(Qt::black);
     }
@@ -6668,6 +6697,7 @@ void SpectrumWidget::saveCurrentWaterfallStreamState()
     updated.waterfall = std::move(m_waterfall);
     updated.waterfallSupplemental = std::move(m_waterfallSupplemental);
     updated.wfWriteRow = m_wfWriteRow;
+    updated.visibleTimeRows = std::move(m_wfVisibleTimeRows);
     updated.visibleRowCenterMhz = std::move(m_wfVisibleRowCenterMhz);
     updated.visibleRowBwMhz = std::move(m_wfVisibleRowBwMhz);
     updated.visibleSupplementalCenterMhz =
@@ -6790,6 +6820,10 @@ void SpectrumWidget::restoreCurrentWaterfallStreamState()
         m_waterfallStreamSizeHint = m_waterfall.size();
     }
     m_wfWriteRow = restored.wfWriteRow;
+    // The viewport-size guard above preserves matching timestamp rows. Both
+    // marker readers also tolerate a mismatch: drawing skips it and append
+    // reinitializes the metadata before writing the next row.
+    m_wfVisibleTimeRows = std::move(restored.visibleTimeRows);
     m_wfVisibleRowCenterMhz = std::move(restored.visibleRowCenterMhz);
     m_wfVisibleRowBwMhz = std::move(restored.visibleRowBwMhz);
     m_wfVisibleSupplementalCenterMhz =
@@ -10123,6 +10157,24 @@ void SpectrumWidget::mousePressEvent(QMouseEvent* ev)
             }
 
             menu.addSeparator();
+            QMenu* timeMenu = menu.addMenu(tr("Waterfall Time Markers"));
+            timeMenu->setObjectName(QStringLiteral("waterfallTimeMarkersMenu"));
+            QActionGroup* timeGroup = new QActionGroup(timeMenu);
+            timeGroup->setExclusive(true);
+            for (const int seconds : kWaterfallMarkerIntervals) {
+                const QString label = seconds == 0 ? tr("Off")
+                    : seconds < 60 ? tr("%1 seconds").arg(seconds)
+                    : seconds == 60 ? tr("1 minute")
+                    : tr("%1 minutes").arg(seconds / 60);
+                QAction* action = timeMenu->addAction(label);
+                action->setObjectName(QStringLiteral("waterfallTimeMarkers%1").arg(seconds));
+                action->setCheckable(true);
+                action->setChecked(seconds == m_wfTimeMarkerSeconds);
+                timeGroup->addAction(action);
+                connect(action, &QAction::triggered, this, [this, seconds]() {
+                    setWaterfallTimeMarkerSeconds(seconds);
+                });
+            }
             QAction* tuneGuideAction = menu.addAction("Show Tune Guides");
             tuneGuideAction->setCheckable(true);
             tuneGuideAction->setChecked(m_showTuneGuides);
@@ -14805,6 +14857,10 @@ void SpectrumWidget::renderGpuFrame(QRhiCommandBuffer* cb,
                 static_cast<quint64>(panStatsFftTimer.nsecsElapsed() / 1000);
     }
 
+    prepareWaterfallTimeMarkersGpu(batch,
+        QRect(wfRect.x(), wfRect.y(),
+              std::min(wfContentW, waterfallTimeScaleRect(wfRect).left() - wfRect.left()),
+              wfRect.height()), logicalSize);
     cb->resourceUpdate(batch);
 
     // Begin render pass
@@ -14987,6 +15043,7 @@ void SpectrumWidget::renderGpuFrame(QRhiCommandBuffer* cb,
         cb->draw(4);
     }
 
+    drawWaterfallTimeMarkersGpu(cb);
     cb->endPass();
 
     // VFO flag/widget repositioning now runs earlier (repositionVfoFlags(),
@@ -15041,6 +15098,7 @@ void SpectrumWidget::render(QRhiCommandBuffer* cb)
 
 void SpectrumWidget::releaseResources()
 {
+    releaseWaterfallTimeMarkersGpu();
     releaseWaterfallFramePipelineResources();
     delete m_wfPipeline;     m_wfPipeline = nullptr;
     delete m_wfSrb;          m_wfSrb = nullptr;
@@ -15412,6 +15470,9 @@ void SpectrumWidget::paintEvent(QPaintEvent* ev)
     } else {
         drawDbmScale(p, specRect);
     }
+    drawWaterfallTimeMarkers(p, QRect(wfRect.x(), wfRect.y(),
+        std::min(wfContentRect.width(), waterfallTimeScaleRect(wfRect).left() - wfRect.left()),
+        wfRect.height()));
     drawTimeScale(p, wfRect);
 
     if (PerfTelemetry::instance().enabled()) {