@@ -536,7 +536,14 @@ void Dsp::processGeneralMode(juce::AudioBuffer<float>& buffer,
     const float mixDecisionTrust = clamp01(signalTrust
                                            * (1.0f - 0.22f * clamp01(params.monoScore))
                                            * (1.0f - 0.18f * compressionPenalty));
-    const float generalMomentaryCoeff = timeCoeff(sr, 0.40f);
+    // Spike detection compares momentary against short-term level (overshootDb
+    // below). At 0.40s this never fully settles between the ~0.4-0.5s repeats
+    // typical of rhythmic/pulsing program material, so overshootDb reads as
+    // continuously elevated instead of a brief transient - generalSpikeGain
+    // then stays pinned near its floor for the whole passage rather than
+    // ducking only genuine spikes. 0.06s decays between such repeats while
+    // still smoothing over a handful of samples.
+    const float generalMomentaryCoeff = timeCoeff(sr, 0.06f);
     const float generalShortCoeff = timeCoeff(sr, 3.0f);
     const float generalBaselineRiseCoeff = timeCoeff(sr, 4.2f);
     const float generalBaselineFallCoeff = timeCoeff(sr, 8.0f);
 
@@ -151,8 +151,17 @@ class CorrectionEngine {
         // decompConfidence of exactly zero (true unvoiced) is how it knows
         // to forget between phrases; weak-but-nonzero confidence just
         // contributes weak evidence rather than forcing a reset.
+        // Previous frame's segment (segmenter.process() for THIS frame
+        // hasn't run yet) grounds a small switching-inertia bias: real
+        // sustain/vibrato should resist a single competing frame, a
+        // passing/onset/slide segment should not. See
+        // TargetEstimator::update()'s stabilityBias doc for why this is
+        // safe (segmenter is independent of the estimator's own choice).
+        const NoteSegment& previousSegment = segmenter.currentSegment();
+        const float stabilityBias = previousSegment.behaviourProb[static_cast<int>(Behaviour::sustain)]
+            + previousSegment.behaviourProb[static_cast<int>(Behaviour::vibrato)];
         const auto target = estimator.update(frame.centreCents, frame.decompConfidence,
-                                              scaleMask, natural);
+                                              scaleMask, natural, stabilityBias);
         lastTarget = {
             target.valid,
             target.midiNote,
 
@@ -62,6 +62,7 @@ class TargetEstimator {
 
     void reset() noexcept {
         count = 0;
+        lastMidi = -1000000;
     }
 
     struct Result {
@@ -72,12 +73,33 @@ class TargetEstimator {
         float marginLog = 0.0f;       // best score - runner-up score
     };
 
+    // Bounds how much a single frame's switching-inertia bonus can help the
+    // previously-held target. Deliberately small relative to kInRangeBonus
+    // (3.0): this must nudge a close call, never let a stale target beat
+    // fresh, clearly-better evidence outright.
+    static constexpr float kSwitchInertiaMax = 0.8f;
+
     // One call per analysis frame, always (even low-confidence/unvoiced —
     // that is how the estimator knows to forget between phrases).
     // decompConfidence == 0 means "nothing to go on": the pool resets so the
     // next phrase starts fresh instead of gliding from a stale target.
+    //
+    // stabilityBias (0..1, typically the caller's previous-frame
+    // behaviourProb[sustain]+[vibrato] from VxTuneSegmenter) grounds a small
+    // per-frame preference for whichever note won last frame: real
+    // sustain/vibrato should not flip on a single frame's competing blip,
+    // while a genuine passing/onset/slide segment (bias near 0) switches as
+    // fast as it always has. The segmenter computes this independently of
+    // which note the estimator itself favours (see VxTuneSegmenter.h), so
+    // this is not the estimator validating its own past choice - the
+    // failure mode this project already caught once with the reverted
+    // octave-continuity fix. The bonus is applied only to THIS frame's
+    // decision, never folded into a candidate's stored score, so it cannot
+    // accumulate across frames the way stale evidence itself once did (see
+    // kScoreFloor/kInRangeBonus above).
     Result update(const float centreCents, const float decompConfidence,
-                  const std::uint16_t scaleMask, const float natural) noexcept {
+                  const std::uint16_t scaleMask, const float natural,
+                  const float stabilityBias = 0.0f) noexcept {
         if (decompConfidence <= 0.0f) {
             reset();
             return {};
@@ -124,16 +146,34 @@ class TargetEstimator {
         if (count == 0)
             return {};
 
+        const float bias = stabilityBias <= 0.0f
+            ? 0.0f
+            : (stabilityBias >= 1.0f ? 1.0f : stabilityBias);
+        const float inertiaBonus = bias * kSwitchInertiaMax;
+        const auto effective = [this, inertiaBonus](const int i) noexcept {
+            return candidates[i].score
+                + (candidates[i].midi == lastMidi ? inertiaBonus : 0.0f);
+        };
+
         int bestIdx = 0;
-        for (int i = 1; i < count; ++i)
-            if (candidates[i].score > candidates[bestIdx].score)
+        float bestEffective = effective(0);
+        for (int i = 1; i < count; ++i) {
+            const float e = effective(i);
+            if (e > bestEffective) {
+                bestEffective = e;
                 bestIdx = i;
+            }
+        }
         int runnerIdx = -1;
+        float runnerEffective = 0.0f;
         for (int i = 0; i < count; ++i) {
             if (i == bestIdx)
                 continue;
-            if (runnerIdx < 0 || candidates[i].score > candidates[runnerIdx].score)
+            const float e = effective(i);
+            if (runnerIdx < 0 || e > runnerEffective) {
                 runnerIdx = i;
+                runnerEffective = e;
+            }
         }
 
         Result r;
@@ -142,9 +182,10 @@ class TargetEstimator {
         r.errorCents = centreCents - 100.0f * static_cast<float>(candidates[bestIdx].midi - 69);
         r.runnerUpMidiNote = runnerIdx >= 0 ? candidates[runnerIdx].midi : -1;
         r.marginLog = runnerIdx >= 0
-            ? candidates[bestIdx].score - candidates[runnerIdx].score
-            : candidates[bestIdx].score;
+            ? bestEffective - runnerEffective
+            : bestEffective;
 
+        lastMidi = r.midiNote;
         return r;
     }
 
@@ -189,6 +230,7 @@ class TargetEstimator {
     float frameDur = 1.0f / 187.5f;
     Candidate candidates[kMaxCandidates] {};
     int count = 0;
+    int lastMidi = -1000000;
 };
 
 } // namespace vxsuite::tune
@@ -488,6 +488,58 @@ void testMusicalAuthorityProtectsUnstableFrames() {
               + std::to_string(settled) + "c)");
 }
 
+void testTargetSwitchingInertiaAtBoundary() {
+    std::printf("Target-switching inertia damps flicker at a semitone "
+                "boundary without blocking a genuine note change:\n");
+    // A single-frame competing blip amid a long-held note would never flip
+    // the estimator's argmax anyway - the incumbent's accumulated evidence
+    // dwarfs one fresh frame's contribution by design (that is the whole
+    // point of evidence accumulation). The regime this fix actually targets
+    // is a noisy real pitch estimate hovering almost exactly on a semitone
+    // boundary during a genuinely held/sustained note, where per-frame
+    // jitter can tip the instantaneous argmax back and forth many times a
+    // second - the F4-round-6 "on/off" flicker bug class, one level up
+    // (which NOTE is favoured, not just whether correction engages).
+    constexpr double frameRate = 48000.0 / 256.0;
+    CorrectionEngine engine;
+    engine.prepare(frameRate, CorrectionEngine::Config {});
+
+    std::mt19937 rng(12345);
+    std::uniform_real_distribution<float> jitter(-8.0f, 8.0f);
+
+    int switches = 0;
+    int lastMidi = -1000000;
+    // Hover exactly between A3 (0c) and A#3 (100c) with small per-frame
+    // jitter, both candidates symmetric at +/-50c.
+    for (int i = 0; i < 60; ++i) {
+        auto frame = syntheticFrame(220.0f, 50.0f + jitter(rng), 0.95f,
+                                     EstimateReason::nominal);
+        frame.timeSamples = static_cast<std::int64_t>(i * 256);
+        engine.process(frame, 1.0f, 0.5f);
+        const int midi = engine.currentTargetSnapshot().midiNote;
+        if (lastMidi != -1000000 && midi != lastMidi)
+            ++switches;
+        lastMidi = midi;
+    }
+    check(switches <= 6,
+          "target does not flicker every frame while hovering at the "
+              "boundary (got " + std::to_string(switches)
+              + " switches over 60 frames)");
+
+    // Contrast: a genuine, unambiguous note change (A3 -> C4, three
+    // semitones, unmistakably nearer the new note every frame) must still
+    // land promptly - inertia must not create a new stuck-target bug.
+    for (int i = 0; i < 30; ++i) {
+        auto frame = syntheticFrame(261.63f, 0.0f, 0.95f, EstimateReason::nominal);
+        frame.timeSamples = static_cast<std::int64_t>((60 + i) * 256);
+        engine.process(frame, 1.0f, 0.5f);
+    }
+    const int finalMidi = engine.currentTargetSnapshot().midiNote;
+    check(finalMidi == 60,
+          "genuine note change to C4 still converges despite switching "
+              "inertia (got midi " + std::to_string(finalMidi) + ")");
+}
+
 // Runs detector -> decomposition -> engine on `audio` and returns the
 // dominant behaviour + its probability at the LAST analysed frame -
 // i.e. after the whole clip has been seen, matching how a real-time
@@ -684,6 +736,7 @@ int main() {
     testDivergenceGuardStopsChasingAGlide();
     testDoesNotTouchInTune();
     testMusicalAuthorityProtectsUnstableFrames();
+    testTargetSwitchingInertiaAtBoundary();
     testBehaviourDistribution();
     testScaleAwareTargets();
     testVibratoSurvivesCorrection();