@@ -138,7 +138,7 @@ there is an interface. None of them stops the tracker or reseeds the filter.
 | Key | |
 |---|---|
 | `space` | tap the tempo. Three taps are enough; the fold window moves onto what you tapped, so the readout and the setting agree on why the tempo is what it is. |
-| `d` | downbeat now — the next beat starts the bar, and goes on starting it. With `--link`, that beat is placed with `forceBeatAtTime`, so peers move too. |
+| `d` | downbeat now — the beat nearest the press starts the bar, and goes on starting it. Press it *on* the downbeat you can hear: the beat just gone is the one it takes. With `--link`, the new phase is placed with `forceBeatAtTime`, so peers move too. |
 | `h` / `x` | halve and double the published tempo, keeping the lock. |
 | `[` / `]` | move the latency offset by 5 ms, on the beat timestamps and the transports alike. |
 | `f` | turn the octave fold off and on. |
 
@@ -134,7 +134,7 @@ void printUsage(std::ostream& out) {
         << "                      substring of its name, or its index)\n"
         << "      The outputs need a live input; over a file only the beats are printed.\n"
         << "      On a live input the manual controls are on the keyboard: space taps the\n"
-        << "      tempo, d snaps the downbeat to the next beat, h and x halve and double\n"
+        << "      tempo, d snaps the bar to the nearest beat, h and x halve and double\n"
         << "      it, l pins the lock so a breakdown cannot drop it, [ and ] move the\n"
         << "      latency offset, f turns the octave fold off and on, q stops. These need\n"
         << "      a console: MinTTY, which Git Bash uses, is not one, and the banner says\n"
@@ -1206,7 +1206,7 @@ int runTrackDevice(const TrackArgs& args, const takt4::model::ModelWeights& weig
         }
         case 'd':
             (void)engine->post(Command::snapDownbeat());
-            std::cout << "  downbeat: the next beat starts the bar\n";
+            std::cout << "  downbeat: the nearest beat starts the bar\n";
             break;
         case 'h':
             (void)engine->post(Command::halve());
 
@@ -28,8 +28,9 @@ struct Command {
         SetTempoOptions,
         Halve,    ///< §5.5's ÷2.
         Redouble, ///< §5.5's ×2.
-        /// §5.5's manual downbeat: the next beat called starts the bar. The one command
-        /// the handoff calls non-negotiable, and the one an operator reaches for first.
+        /// §5.5's manual downbeat: the beat nearest the press starts the bar. The one
+        /// command the handoff calls non-negotiable, and the one an operator reaches for
+        /// first.
         SnapDownbeat,
         /// §5.5's tap tempo, already measured: `tracking::TapTempo` counts the taps on
         /// whichever thread they arrive on, and only the tempo it worked out travels here.
 
@@ -103,8 +103,12 @@ void TempoTracker::reset() noexcept {
     filterBeatInBar_ = 0;
     barOffset_ = 0;
     snapPending_ = false;
+    snapUnsent_ = false;
     snapAwaitingFilter_ = false;
     sinceSnap_ = 0;
+    framesSinceBeat_ = 0;
+    beatsSeen_ = 0;
+    filterIntervalFrames_ = 0;
     beatFrames_.clear();
 }
 
@@ -295,8 +299,49 @@ void TempoTracker::seedTempo(double bpm) noexcept {
     }
 }
 
+bool TempoTracker::lastBeatIsNearer() const noexcept {
+    if (beatsSeen_ == 0 || filterIntervalFrames_ == 0) {
+        return false; // no beat behind, or no idea when the next one is due
+    }
+    // Nearer than the next beat, whose best estimate is one period after the last one. The
+    // comparison is doubled rather than halved so it stays in whole frames.
+    return 2 * framesSinceBeat_ < filterIntervalFrames_;
+}
+
 void TempoTracker::snapDownbeat() noexcept {
-    snapPending_ = true;
+    // Either way a correction is now owed to the outputs, and the next beat carries it.
+    snapUnsent_ = true;
+    if (!lastBeatIsNearer()) {
+        snapPending_ = true; // the beat being pointed at has not happened yet
+        return;
+    }
+    // The operator is pointing at the beat just called, so the bar starts there and this
+    // beat's successor is beat 2 — not beat 1, which is what made every snap read a beat
+    // late. Nothing is left pending: the rotation is known now and takes effect now.
+    snapPending_ = false;
+    const bool wasBarStart = state_.beatInBar == 1;
+    startBarHere();
+    state_.beatInBar = 1;
+    if (!wasBarStart) {
+        // A bar the operator has just declared, which the count above did not make. Had it
+        // already been beat 1 the bar was counted when it was called, and counting it twice
+        // would make a snap that changed nothing move the bar number.
+        ++state_.bars;
+    }
+}
+
+void TempoTracker::startBarHere() noexcept {
+    const std::uint32_t meter = state_.beatsPerBar;
+    snapAwaitingFilter_ = !(filterBeatInBar_ != 0 && meter > 0);
+    if (snapAwaitingFilter_) {
+        // Nothing to rotate yet. Count from here, and turn the count into an offset the
+        // moment the filter first has an opinion.
+        sinceSnap_ = 0;
+        return;
+    }
+    // Rotate so this beat comes out as 1. Reducing the position first keeps this right
+    // through a meter change that leaves the filter past the end of a bar.
+    barOffset_ = (meter - (filterBeatInBar_ - 1) % meter) % meter;
 }
 
 void TempoTracker::setLockPinned(bool pinned) noexcept {
@@ -344,17 +389,11 @@ void TempoTracker::advanceBar(bool filterCalledDownbeat) noexcept {
     const bool haveFilterBar = filterBeatInBar_ != 0;
 
     if (snapPending_) {
+        // A snap that named a beat still to come: this is it, so the bar starts here. The
+        // one that named the beat just gone rotated in snapDownbeat() and left nothing
+        // pending, which is why it falls through to the ordinary count below.
         snapPending_ = false;
-        snapAwaitingFilter_ = !(haveFilterBar && meter > 0);
-        if (snapAwaitingFilter_) {
-            // Nothing to rotate yet. Count from here, and turn the count into an offset
-            // the moment the filter first has an opinion.
-            sinceSnap_ = 0;
-        } else {
-            // Rotate so this beat comes out as 1. Reducing the position first keeps this
-            // right through a meter change that leaves the filter past the end of a bar.
-            barOffset_ = (meter - (filterBeatInBar_ - 1) % meter) % meter;
-        }
+        startBarHere();
     } else if (snapAwaitingFilter_ && meter > 0) {
         sinceSnap_ = (sinceSnap_ + 1) % meter;
         if (haveFilterBar) {
@@ -479,6 +518,13 @@ std::optional<BeatEvent> TempoTracker::process(const TrackedFrame& frame) noexce
     state_.confidence = smoothedConfidence_;
     state_.rawBpm = frame.bpm;
     state_.beatsPerBar = frame.beatsPerBar;
+    // Where in the beat we are, for a snap arriving between two frames to read. Kept even
+    // when the interval is zero, because it is the last one known that says how long a beat
+    // lasts, not this frame's absence of one.
+    ++framesSinceBeat_;
+    if (frame.intervalFrames > 0) {
+        filterIntervalFrames_ = frame.intervalFrames;
+    }
 
     // The lock is decided on the state space's own whole-frame interval, never on the
     // refined tempo. The refinement moves by tenths of a BPM from one frame to the next,
@@ -513,6 +559,8 @@ std::optional<BeatEvent> TempoTracker::process(const TrackedFrame& frame) noexce
     const bool emitted = frame.emitted != TrackedFrame::Emitted::None;
     if (emitted) {
         rememberBeat(frame.frameIndex);
+        framesSinceBeat_ = 0;
+        ++beatsSeen_;
     }
 
     // Holding below the confidence gate keeps whatever was last published (§5.5: "hold the
@@ -567,7 +615,8 @@ std::optional<BeatEvent> TempoTracker::process(const TrackedFrame& frame) noexce
         return std::nullopt;
     }
 
-    const bool snapped = snapPending_;
+    const bool snapped = snapUnsent_;
+    snapUnsent_ = false;
     advanceBar(frame.emitted == TrackedFrame::Emitted::Downbeat);
     ++state_.beats;
 
 
@@ -39,9 +39,16 @@ struct BeatEvent {
     double bpm = 0.0;
     bool locked = false;
     double confidence = 0.0;
-    /// True on the one beat an operator's downbeat snap landed on. §5.6 reserves Link's
+    /// True on the first beat published under a snap's new bar phase. §5.6 reserves Link's
     /// `forceBeatAtTime` for exactly this beat — a `requestBeatAtTime` would be moved to
     /// where the session's phase already matches, which is the phase being corrected.
+    ///
+    /// That is the beat the operator pointed at only when they pointed at one still to
+    /// come. A snap naming the beat just gone (see `snapDownbeat`) cannot mark it, because
+    /// it has already been sent, so the flag rides the next beat instead — which carries
+    /// the identical correction, since `LinkSession::forceBeat` is given the *bar
+    /// position*, and forcing beat 2 of the bar moves a peer's phase exactly as far as
+    /// forcing beat 1 would.
     bool snapped = false;
 };
 
@@ -286,8 +293,33 @@ class TempoTracker {
     /// window by hand — a tap confirming what is already tracked must not cost sync.
     void seedTempo(double bpm) noexcept;
 
-    /// §5.5's manual downbeat: the next beat called starts the bar, and every bar after
-    /// it is counted from there.
+    /// §5.5's manual downbeat: the beat the operator is pointing at starts the bar, and
+    /// every bar after it is counted from there.
+    ///
+    /// **Which beat that is, is the whole difficulty.** This used to be "the next beat
+    /// called", and that is a beat late for the only way the control is ever used: a
+    /// person presses the button *on* the downbeat they can hear, by which time the
+    /// tracker has already called it, so the bar came out anchored to beat 2. The user's
+    /// report, 2026-09-05: "if I press the downbeat, it should start at the very beginning
+    /// of the four dots, but it's always one too slow." §5.5 wants a control that "snaps
+    /// bar phase immediately", and a beat late is not immediately.
+    ///
+    /// So it takes the **nearest** beat: the one just called if it is less than half a beat
+    /// period behind, and the one still to come otherwise. Nothing is assumed about which
+    /// side of the beat a press lands on, and nothing needs to be — the split is
+    /// symmetric, so an operator anticipating the beat and an operator reacting to it both
+    /// land on the beat they meant, and the pipeline's own delay only moves where inside
+    /// that window the press falls. There is deliberately no constant to tune: the
+    /// alternative is a fixed offset for a reaction time nobody has measured.
+    ///
+    /// The half is measured against the *filter's* beat period, never the published tempo,
+    /// because ÷2 and ×2 move the second and not the first — after a ÷2 the beats keep
+    /// arriving at the rate they always did.
+    ///
+    /// Naming the beat just gone takes effect **at once**: `beatInBar` is 1 before this
+    /// returns, so the count moves under the operator's finger instead of a beat later.
+    /// What cannot move is that beat's own outgoing event, which has been sent already —
+    /// the correction reaches the transports on the next beat, marked `BeatEvent::snapped`.
     ///
     /// The rotation this sets up is **kept** until the next snap or a reset, rather than
     /// being given back on the filter's next downbeat call. §5.5 asks for this because
@@ -365,6 +397,14 @@ class TempoTracker {
     /// Advances the filter's own bar position and turns it into the published one,
     /// applying whatever a snap has rotated the bar by. Called once per emitted beat.
     void advanceBar(bool filterCalledDownbeat) noexcept;
+    /// Rotates the bar so that the beat `filterBeatInBar_` is currently on comes out as 1.
+    /// A snap that names the beat just gone calls this before the position advances; one
+    /// that names the beat still to come calls it after. Same arithmetic, one beat apart —
+    /// which is the entire difference between the two.
+    void startBarHere() noexcept;
+    /// Whether the beat the filter last called is nearer than the one it will call next.
+    /// False when neither is known yet, so a snap before the first beat waits for it.
+    bool lastBeatIsNearer() const noexcept;
     /// The mean beat-to-beat gap in frames, over the gaps within `refineGapTolerance` of
     /// `cloudIntervalFrames`. Zero when there are not enough of them.
     double refinedIntervalFrames(double cloudIntervalFrames) const noexcept;
@@ -403,11 +443,23 @@ class TempoTracker {
     std::uint32_t filterBeatInBar_ = 0; ///< 1 on the filter's downbeat; 0 until it calls one
     std::uint32_t barOffset_ = 0;       ///< beats added to the filter's position
     bool snapPending_ = false;          ///< a snap waiting for the next beat to land on
+    /// A snap whose new bar phase has not reached the outputs yet. Set by every snap and
+    /// spent on the next beat, which is the earliest one that can carry it either way: a
+    /// snap naming a beat still to come is carried by that beat, and one naming the beat
+    /// just gone is carried by the beat after it. See `BeatEvent::snapped`.
+    bool snapUnsent_ = false;
     /// A snap that arrived before the filter had ever called a downbeat has nothing to
     /// rotate yet, so the bar runs from the snap itself until the filter does — and
     /// `sinceSnap_` is what turns that into an offset when it finally happens.
     bool snapAwaitingFilter_ = false;
     std::uint32_t sinceSnap_ = 0;
+    /// How long ago the last beat was and how far apart the beats are, both in frames, so
+    /// that a snap arriving between two frames can tell which beat it means. The period is
+    /// the filter's own, untouched by the fold or by ÷2 and ×2. Zero beats seen means the
+    /// first is still to come.
+    std::uint64_t framesSinceBeat_ = 0;
+    std::uint64_t beatsSeen_ = 0;
+    std::uint32_t filterIntervalFrames_ = 0;
 
     /// The frames the last few beats were called on, oldest first. Bounded by
     /// `refineOverBeats + 1`, so this allocates once and never grows.
 
@@ -652,11 +652,12 @@ export component MainWindow inherits Window {
           // §5.5: "Big keyboard / MIDI / OSC downbeat now ... Non-negotiable — the best
           // online downbeat tracker in the world scores 56% F1, and being two beats out
           // is worse than one tap." So it is the widest thing in the row.
-          // Lit from the press until the beat it lands on, because §5.5's snap takes
-          // effect on the *next* beat the tracker calls — up to nine hundred milliseconds
-          // at 70 BPM. A button that does nothing for most of a second, and then shifts a
-          // bar phase that is hard to see moving, reads as a button that does nothing at
-          // all. This is the difference between "it is coming" and "it is broken".
+          // Lit from the press until the next beat, which is when the correction reaches
+          // the outputs — up to nine hundred milliseconds at 70 BPM. A press on the beat
+          // moves the bar dots immediately (the tracker takes the nearer beat, so it names
+          // the one just heard), but a press between beats still has to wait for one, and a
+          // button that does nothing for most of a second, then shifts a bar phase that is
+          // hard to see moving, reads as a button that does nothing at all.
           Press {
             text: "DOWNBEAT";
             primary: root.running;
 
@@ -459,11 +459,12 @@ void WindowController::snapDownbeat() {
     if (!tracker_.engine().post(engine::Command::snapDownbeat())) {
         return; // queue full; nothing is coming, so do not light the button
     }
-    // §5.5's snap deliberately takes effect on the *next* beat the tracker calls, which at
-    // 70 BPM is the best part of a second away. Remember the beat count now so the redraw
-    // can tell when it has landed, and light the button until then — the press is
-    // otherwise entirely invisible, and a bar phase shifting is hard to see moving even
-    // once it does.
+    // The snap's correction reaches the outputs on the next beat the tracker calls, which
+    // at 70 BPM is the best part of a second away — even when the bar dots move at once,
+    // which they do whenever the press named the beat just gone. Remember the beat count
+    // now so the redraw can tell when it has landed, and light the button until then: a
+    // press between beats is otherwise entirely invisible, and a bar phase shifting is hard
+    // to see moving even once it does.
     snapAwaitingBeat_ = tracker_.engine().state().beats;
     window_->set_snap_pending(true);
 }
 
@@ -94,8 +94,8 @@ TEST_CASE("the control addresses reach the tracker", "[control]") {
     (void)engine->step();
     CHECK_THAT(engine->state().bpm, WithinAbs(raw, 1e-6));
 
-    // A downbeat snap lands on the next beat the tracker calls; what that then means to
-    // the bar is tests/engine/beat_engine_test.cpp's business.
+    // A downbeat snap lands on the beat nearest the message; what that then means to the
+    // bar is tests/engine/beat_engine_test.cpp's business.
     CHECK(control.dispatch("/takt4/ctl/downbeat", std::nullopt));
     (void)engine->step();