Take a lost lock back on the beats' own evidence; clocks and rule lengths follow the beats going out

A lock taken at a wrong tempo (double time, or 176 over a record at 130) and then lost left the
number frozen there while every beat went out at the record's real tempo — for minutes, because
replacing a long-held lock needs up to 300 frames of unbroken agreement and the decoder's tempo
dips past the lock's band as each beat arrives. Over the 109-g playlist played straight through,
steady beats went out under a number more than 6 % off them for 31.8 of 715 live minutes.

Tracker:
- Unlocked after a lock, once the lock has been gone 3 s, the last eight published beats are
  steady (interquartile range under 5 % of the median gap) and the decoder's tempo over the last
  beat agrees with them, the lock moves to the rate the beats are going out at. Replacements
  only: a first lock, and a lock coming back to the tempo published, are earned as before.
- The octave the filter's beats sit at against its cloud is kept through a lock move, and the
  first lock after no signal, only if the beats do not cleanly show another; it used to be kept
  through everything but a reset.
- TempoState::gridBpm: the rate the published beats are going out at — the number on the beats'
  octave while it agrees with them, their measured rate when it does not. clockOctaves: the
  operator's x2, which doubles the number and cannot double the beats.

Outputs:
- The MIDI clock and Link run at gridBpm, times two under a x2; the clock's receiver and Link's
  session count that many of their beats to each beat going out, so a x2 or a number left behind
  no longer stops and restarts a receiver every bar, and a receiver's bar 1 is the tracker's
  downbeat.
- The beat scheduler predicts at gridBpm, and a rule's waits and follow-ups in beats or bars, and
  TEST's hold, are counted in it (Context::beatSeconds).

Window: the line under the tempo says what the beats are going out at whenever the outputs are
live, locked or not ("number held from last lock" unlocked, "press ÷2 to match" locked).

Measured over the same playlist played straight through: steady beats under a number more than
6 % off them for 9.3 minutes rather than 31.8, the longest stretch 9 s rather than 145; tracked a
record at a time, 6.1 minutes rather than 22.7. The refeval gate passes (tempo accuracy up, beat F
unchanged), Ballroom is bit-identical, and on the agreed fifteen the number is off the reference
for 331 s rather than 405 s while the outputs are live (258 rather than 273 with the 70-140
window).

takt4-cli --trace writes beats_bpm and grid_bpm.

Author: Fohdeesha

src/cli/main.cpp

@@ -1068,7 +1068,8 @@ class FrameTracer {
         // the first of them a trace cannot tell that story at all.
         out_ << "frame\ttime\tbeat_act\tdown_act\tgathering\tinterval\trefined_interval"
                 "\tcloud_bpm\tagreement\tbpm\tconfidence\tlocked\tholding\tmeter\tbeat_in_bar"
-                "\temitted\tpublished\tflux\tintensity\tonset\tinterp\tacquired\tno_signal\n"
+                "\temitted\tpublished\tflux\tintensity\tonset\tinterp\tacquired\tno_signal"
+                "\tbeats_bpm\tgrid_bpm\n"
              << std::fixed << std::setprecision(6);
     }
 
@@ -1088,7 +1089,8 @@ class FrameTracer {
              << static_cast<int>(tracked.emitted) << '\t' << (frame.beat ? 1 : 0) << '\t'
              << frame.activation.flux << '\t' << static_cast<int>(frame.activation.intensity)
              << '\t' << (frame.activation.onset ? 1 : 0) << '\t' << (frame.interpolated ? 1 : 0)
-             << '\t' << (state.acquired ? 1 : 0) << '\t' << (state.noSignal ? 1 : 0) << '\n';
+             << '\t' << (state.acquired ? 1 : 0) << '\t' << (state.noSignal ? 1 : 0) << '\t'
+             << state.beatsBpm << '\t' << state.gridBpm << '\n';
     }
 
 private:

src/core/output/beat_scheduler.cpp

@@ -6,6 +6,11 @@
 namespace takt4::output {
 
 double beatSeconds(const tracking::TempoState& state, double bpm) noexcept {
+    // The tracker's own answer, where it has one: the beats' measured rate whenever the number
+    // has been left behind by them, which no octave of the number can say (`TempoState::gridBpm`).
+    if (state.gridBpm > 0.0) {
+        return 60.0 / state.gridBpm;
+    }
     if (!(bpm > 0.0)) {
         return 0.0;
     }

src/core/output/beat_scheduler.hpp

@@ -131,8 +131,11 @@ class BeatScheduler {
 /// published tempo **only when the beats are on the published grid**. A ×2 doubles the number
 /// and cannot double the beats, and a fold the music has not yet backed halves the number and
 /// leaves the beats alone (`TempoState::beatDivisor`); in both the beats are an octave from the
-/// tempo. Worked out from the rate the filter calls beats at and the divisor, snapped to the
-/// octave of the published tempo so the refined tempo's precision is kept. Zero with no tempo.
+/// tempo. `TempoState::gridBpm` is the tracker's answer, and it is used whenever it is set: it
+/// also covers a number left behind by the beats at some other ratio — a lock lost at 176 over a
+/// record at 130 — which no octave of the number reaches. Without one (a state built by hand),
+/// worked out from the rate the filter calls beats at and the divisor, snapped to the octave of
+/// the published tempo so the refined tempo's precision is kept. Zero with no tempo.
 double beatSeconds(const tracking::TempoState& state, double bpm) noexcept;
 
 } // namespace takt4::output

src/core/output/output_runner.cpp

@@ -1107,6 +1107,7 @@ trigger::Context OutputRunner::contextAt(double now) const {
     const engine::EngineIntensity intensity = engine_.intensity();
     trigger::Context context;
     context.bpm = state.bpm;
+    context.beatSeconds = state.gridBpm > 0.0 ? 60.0 / state.gridBpm : 0.0;
     context.confidence = state.confidence;
     context.locked = state.locked;
     context.meter = state.beatsPerBar;
@@ -1126,6 +1127,7 @@ void OutputRunner::fireBeat(const ScheduledBeat& beat, double now) {
     // then held to — see `trigger::Message::moment`.
     trigger::Context context = contextAt(now);
     context.bpm = beat.event.bpm;
+    context.beatSeconds = beat.event.gridBpm > 0.0 ? 60.0 / beat.event.gridBpm : 0.0;
     context.confidence = beat.event.confidence;
     context.locked = beat.event.locked;
     context.meter = beat.event.beatsPerBar;

src/core/output/transports.cpp

@@ -36,6 +36,19 @@ std::int64_t toMicros(double seconds) noexcept {
     return static_cast<std::int64_t>(seconds * 1e6);
 }
 
+/// How many of the clocks' beats go by in one published beat: one, or two or four under the
+/// operator's ×2 — which doubles the tempo the clocks carry and cannot double the beats
+/// (`TempoState::clockOctaves`).
+std::uint32_t clockBeatsPerBeat(const tracking::BeatEvent& event) noexcept {
+    return std::uint32_t{1} << std::clamp(event.clockOctaves, 0, 2);
+}
+
+/// The rate the published beats are going out at (`TempoState::gridBpm`), or the published tempo
+/// for a beat that does not say — one built by hand.
+double gridBpmOf(const tracking::BeatEvent& event) noexcept {
+    return event.gridBpm > 0.0 ? event.gridBpm : event.bpm;
+}
+
 /// Why `device` would not open, in the words its row shows — from inside the `catch` that
 /// caught what opening it threw. Not on the machine and held by another program are told apart:
 /// they have different fixes, and the first used to be said of both.
@@ -605,9 +618,16 @@ double Transports::tailSeconds() const noexcept {
 void Transports::publishClocks(const tracking::BeatEvent& event, std::int64_t hostMicros,
                                double beatTime) {
     const std::int64_t latencyMicros = latencyMicros_.load(std::memory_order_relaxed);
+    // **The beats going out, never the number blind** — `TempoState::gridBpm`. A number frozen at
+    // 188 where a lost lock left it, over beats at 94, ticked a receiver at twice the music and
+    // restarted it every bar, since its quarter notes and the tracker's beats then disagreed two
+    // to one. The operator's ×2 alone runs the clock above the beats, which is what it is for.
+    const double grid = gridBpmOf(event);
+    const std::uint32_t perBeat = clockBeatsPerBeat(event);
+    const double tempo = grid * static_cast<double>(perBeat);
     for (Clock& clock : clocks_) {
         MidiClock& midi = *clock.clock;
-        midi.setTempo(event.bpm);
+        midi.setTempo(tempo);
         // The beat's own time, not the round that drained it: the audio arrived a pipeline's
         // worth of time before the beat was called, and the clock used to be synced to when it
         // was *drained* — late by that pipeline, plus the offset (§5.5). The clock steers
@@ -623,18 +643,24 @@ void Transports::publishClocks(const tracking::BeatEvent& event, std::int64_t ho
         // 2026-09-25, M6). The tracker publishes `beatInBar` 0 before it has found a bar, and
         // that was read as beat 1 — so a receiver's bar 1 could land on beat 2, 3 or 4 and stay
         // there for the run. Link's path already waited for this (`phased`, below).
-        if (event.locked && event.bpm > 0.0 && event.beatInBar > 0 && event.beatsPerBar > 0) {
-            const double beat = 60.0 / event.bpm;
+        if (event.locked && grid > 0.0 && event.beatInBar > 0 && event.beatsPerBar > 0) {
+            const double beat = 60.0 / grid;
             const std::uint32_t meter = event.beatsPerBar;
             const std::uint32_t inBar = std::clamp<std::uint32_t>(event.beatInBar, 1, meter);
+            // The receiver counts its own quarter notes, `perBeat` of them to a published beat, and
+            // its bars in those: the tracker's downbeat starts one of them, and this beat is the
+            // start of the receiver's quarter note `(inBar - 1) * perBeat` from there.
+            const std::uint32_t receiverBeat = ((inBar - 1) * perBeat) % meter + 1;
             if (midi.waitingToStart()) {
+                // On the tracker's own downbeats, so the receiver's bar 1 is the music's even
+                // where its bar is a part of the tracker's.
                 midi.startOnDownbeat(heardAt - static_cast<double>(inBar - 1) * beat,
                                      static_cast<double>(meter) * beat);
             } else {
                 // And once it has started, its bars follow the tracker's: a DOWNBEAT press, or a
                 // bar found again elsewhere after a break, restarts the receiver on the new
                 // downbeat — Song Position cannot move it while it plays (M19's other half).
-                midi.followBar(heardAt, inBar, meter);
+                midi.followBar(heardAt, receiverBeat, meter);
             }
         }
     }
@@ -682,7 +708,10 @@ void Transports::publishToLink(const tracking::BeatEvent& event, std::int64_t ho
     // the tempo is the hunt's, octave flips and all, and every Start used to overwrite
     // Resolume's tempo with it for a few seconds (the audit's H15). And the next lock snaps
     // again: whatever the session did in between, it is put back under the music then.
-    if (!event.locked || !(event.bpm > 0.0)) {
+    // The beats' rate, and the operator's ×2 over it: see `publishClocks`.
+    const std::uint32_t perBeat = clockBeatsPerBeat(event);
+    const double tempo = gridBpmOf(event) * static_cast<double>(perBeat);
+    if (!event.locked || !(tempo > 0.0)) {
         linkSnapped_ = false;
         return;
     }
@@ -699,15 +728,19 @@ void Transports::publishToLink(const tracking::BeatEvent& event, std::int64_t ho
     // peer's tempo up to 2.6 BPM off meanwhile — slow, wobbling feedback for an operator
     // dragging the delay to line Resolume up. The delay is a place to put the beat, not drift.
     if (linkSnapped_ && std::abs(static_cast<double>(latencyMicros - linkSnappedOffset_)) / 1e6 *
-                                event.bpm / 60.0 >
+                                tempo / 60.0 >
                             kLinkPhaseDeadband) {
         linkSnapped_ = false;
     }
 
     const std::chrono::microseconds at{hostMicros + latencyMicros};
     // Bar phase needs a bar: before the first downbeat only the tempo goes.
     const bool phased = event.beatInBar > 0 && event.beatsPerBar > 0;
-    const double beat = phased ? static_cast<double>(event.beatInBar - 1) : 0.0;
+    // The session's own beat this one falls on: `perBeat` of Link's beats to each published one,
+    // its bar the tracker's meter of them — so under a ×2 the tracker's downbeat starts one of
+    // Link's bars, and the beat after it is Link's beat 3.
+    const double beat =
+        phased ? static_cast<double>(((event.beatInBar - 1) * perBeat) % event.beatsPerBar) : 0.0;
     const double quantum = phased ? static_cast<double>(event.beatsPerBar) : 1.0;
     const auto sendTempo = [&](double bpm) {
         if (std::abs(bpm - lastLinkBpm_) > kLinkTempoEpsilon) {
@@ -726,15 +759,15 @@ void Transports::publishToLink(const tracking::BeatEvent& event, std::int64_t ho
     // *forces* the phase, and so does a DOWNBEAT (§5.6 reserves force for that, and Link's
     // header names bridging an external clock as its legitimate use).
     if (phased && (!linkSnapped_ || event.snapped)) {
-        link_->snap(event.bpm, beat, at, quantum);
-        lastLinkBpm_ = event.bpm;
+        link_->snap(tempo, beat, at, quantum);
+        lastLinkBpm_ = tempo;
         linkSnapped_ = true;
         linkSnappedOffset_ = latencyMicros;
         barsApart_ = 0;
         return;
     }
     if (!phased) {
-        sendTempo(event.bpm);
+        sendTempo(tempo);
         return;
     }
 
@@ -751,8 +784,8 @@ void Transports::publishToLink(const tracking::BeatEvent& event, std::int64_t ho
         // not drift. A tempo nudge would take a hundred beats over a whole beat, so a bar's
         // worth of disagreement in a row is answered the way a DOWNBEAT is.
         if (++barsApart_ >= event.beatsPerBar) {
-            link_->snap(event.bpm, beat, at, quantum);
-            lastLinkBpm_ = event.bpm;
+            link_->snap(tempo, beat, at, quantum);
+            lastLinkBpm_ = tempo;
             linkSnappedOffset_ = latencyMicros;
             barsApart_ = 0;
             return;
@@ -761,7 +794,7 @@ void Transports::publishToLink(const tracking::BeatEvent& event, std::int64_t ho
         barsApart_ = 0;
     }
     if (std::abs(error) < kLinkPhaseDeadband) {
-        sendTempo(event.bpm);
+        sendTempo(tempo);
         return;
     }
     // A session ahead is slowed and one behind is hurried, by the share of the error a beat
@@ -770,7 +803,7 @@ void Transports::publishToLink(const tracking::BeatEvent& event, std::int64_t ho
     // share of however long ago `at` was — (now − at) × Δbpm / 60 beats, thousandths of a beat
     // when `at` is a beat's stamp plus a latency that has already gone by.
     const double nudge = std::clamp(error / kLinkNudgeBeats, -kLinkMaxNudge, kLinkMaxNudge);
-    sendTempo(event.bpm * (1.0 - nudge));
+    sendTempo(tempo * (1.0 - nudge));
 }
 
 } // namespace takt4::output