@@ -258,6 +258,17 @@ release.
   survives at ~72 dB SNR.
 
 ### Fixed
+- `monitor_frequencies()` emitted partial updates several times per sweep
+  pass on real hardware: the pass boundary was a timestamp change, but real
+  `hackrf_sweep` timestamps each row individually (the test stubs shared one
+  timestamp per pass, which hid it), so over a wide span most watched
+  frequencies read `None` in every update -- seen live as a wall of `--`.
+  The boundary is now the sweep wrap (a segment arriving a second time),
+  which is timestamp-independent; every update covers every watched
+  frequency the span covers, pinned by a regression test with per-row
+  timestamps. The `channel_monitor.py` example also now redraws its meter
+  in place (ANSI, Windows VT enabled, scrolling fallback when piped)
+  instead of scroll-printing each frame.
 - Abandoning a live stream could leak a child that held the USB claim for
   the rest of the process: with the consumer gone, the 64 KB stdout pipe
   fills in milliseconds at capture rates and the child blocks inside
 
@@ -21,6 +21,7 @@
 #   Author(s): Lauren Linkous
 ##--------------------------------------------------------------------\
 import argparse
+import os
 import sys
 
 from hackrfpy import HackRF, parse_freq
@@ -58,11 +59,31 @@ def main():
           + ", ".join(l.strip() for l in labels.values())
           + "   (Ctrl-C to stop)")
 
+    # In-place redraw: this is a live METER, so each update overwrites the
+    # previous frame instead of scrolling a log. os.system("") on Windows
+    # switches the classic console into ANSI/VT mode (a documented quirk:
+    # spawning any shell command enables VT processing); it is a no-op
+    # elsewhere. Piped/redirected output falls back to scrolling so logs
+    # stay readable.
+    if os.name == "nt":
+        os.system("")
+    redraw_in_place = sys.stdout.isatty()
+    frame_state = {"drawn": False}
+
     def on_update(update):
         lines = [f"  {labels[f]}  {bar(db)}  "
                  f"{'--' if db is None else f'{db:6.1f} dB'}"
                  for f, db in update.items()]
-        print("\n".join(lines) + "\n")
+        if redraw_in_place:
+            if frame_state["drawn"]:
+                # move the cursor up over the previous frame
+                sys.stdout.write(f"\x1b[{len(lines)}A")
+            # \x1b[2K clears each line so shorter bars leave no residue
+            sys.stdout.write("\n".join("\x1b[2K" + ln for ln in lines) + "\n")
+            sys.stdout.flush()
+            frame_state["drawn"] = True
+        else:
+            print("\n".join(lines) + "\n")
 
     try:
         h.monitor_frequencies(freqs, span_hz=parse_freq(args.span),
 
@@ -165,10 +165,20 @@ def _nearest_power(rows_by_low: dict[int, Any], f: float) -> Any:
         _rows = self.sweep(lo, hi, lna=lna, vga=vga, amp=amp)
         assert _rows is not None          # print_cmd not passed -> real generator
         with StreamCtx(_rows) as gen:
-            rows_by_low = {}
-            last_time = None
+            rows_by_low: dict[int, Any] = {}
             for row in gen:
-                if last_time is not None and row["time"] != last_time and rows_by_low:
+                # A pass is complete when the sweep WRAPS: the same segment
+                # (hz_low) arriving again means a new pass began. The old
+                # boundary was a timestamp change -- but real hackrf_sweep
+                # timestamps each ROW individually, so over a wide span the
+                # "pass" flushed on nearly every row batch, emitting partial
+                # updates where most watched frequencies read None (the test
+                # stubs share one timestamp per pass, which is why stubs
+                # passed while real hardware showed a wall of "--"). Segment
+                # revisit is timestamp-independent and matches the physical
+                # sweep cycle, so every update now covers every watched
+                # frequency the span covers.
+                if row["hz_low"] in rows_by_low:
                     update = {f: _nearest_power(rows_by_low, f) for f in freqs_hz}
                     if on_update is not None:
                         if on_update(update) is False:
@@ -180,7 +190,6 @@ def _nearest_power(rows_by_low: dict[int, Any], f: float) -> Any:
                     if duration is not None and _time.time() - t0 >= duration:
                         break
                 rows_by_low[row["hz_low"]] = row
-                last_time = row["time"]
             # flush the final buffered pass (stream ended before its timestamp
             # rolled over) -- unless we were explicitly stopped by on_update
             if rows_by_low and not stopped:
 
@@ -80,3 +80,37 @@ def test_monitor_reads_covering_bin_not_segment_mean(stub_device):
     # 433.5 MHz -> bin idx 3 (the -20 dB carrier). The segment mean would
     # have read -74; the covering bin reads the carrier itself.
     assert abs(out[0][433.5e6] - (-20.0)) < 0.1
+
+
+# ---- pass detection must survive real per-row timestamps -------------------
+# Real hackrf_sweep timestamps each ROW individually; the stub fixtures used
+# one timestamp per pass, which hid a boundary bug: flushing on timestamp
+# change emitted PARTIAL updates several times per pass on real hardware
+# (most watched frequencies None -- seen live as a wall of "--"). The pass
+# boundary is now the sweep WRAP (a segment arriving again), which is
+# timestamp-independent. These rows reproduce the hardware shape: two full
+# passes over two segments, every row with a distinct timestamp.
+_PER_ROW_TS_PASSES = (
+    "2026-09-19, 12:00:00.100000, 88000000, 88500000, 100000.00, 8192, "
+    "-71.0, -70.0, -69.0, -72.0, -71.0\n"
+    "2026-09-19, 12:00:00.230000, 88500000, 89000000, 100000.00, 8192, "
+    "-70.0, -20.0, -72.0, -73.0, -74.0\n"
+    "2026-09-19, 12:00:00.360000, 88000000, 88500000, 100000.00, 8192, "
+    "-71.5, -70.5, -69.5, -72.5, -71.5\n"
+    "2026-09-19, 12:00:00.490000, 88500000, 89000000, 100000.00, 8192, "
+    "-70.5, -21.0, -72.5, -73.5, -74.5\n"
+)
+
+
+def test_updates_are_complete_despite_per_row_timestamps(stub_device):
+    h = stub_device(sweep=dict(stdout_lines=_PER_ROW_TS_PASSES.strip()
+                               .split("\n")))
+    seen = []
+    h.monitor_frequencies([88.6e6], span_hz=0.4e6,
+                          on_update=lambda u: seen.append(u))
+    # two passes -> exactly two updates (wrap flush + final flush), and BOTH
+    # carry a real reading for the watched frequency -- no partial updates
+    assert len(seen) == 2, f"expected 2 complete updates, got {len(seen)}"
+    assert seen[0][88.6e6] == -20.0       # bin 1 of pass-1 second segment
+    assert seen[1][88.6e6] == -21.0       # same bin, pass 2
+    assert all(u[88.6e6] is not None for u in seen)