@@ -13,3 +13,19 @@
   matched the terminal title. When the operator terminal contains the plugin
   name, capture by explicit window id (`xwininfo -root -tree` filtered by
   PID, then `import -window <id>`).
+- 2026-09-14: Commit c48069e ("minor fixes & tweaks") zeroed the gremlin
+  defaults for `chaos` (0.38), `crunch` (0.18), and `stutter` (0.20) without
+  re-running the plugin core tests. Those three parameters are what drive the
+  per-mode timbre differences, so `downspout_gremlin_core_tests` began failing
+  its mode-separation assertion (Servo vs Ring measured 0.0285 against a 0.035
+  threshold) and stayed broken on `main` until CI surfaced it. Root cause was
+  twofold: a parameter-default change was not treated as a behavioural change
+  worth testing, and the test itself compared modes with a hand-weighted scalar
+  metric (rms/zero-crossings/side/peak/roughness) whose values for every mode
+  pair sat in a 0.03-0.04 band -- the threshold was inside the metric's own
+  scatter, so any default tweak could flip it. Prevention: run the affected
+  plugin's core tests after changing any parameter default, and prefer
+  discriminators with real margin. The mode/scene checks now compare coarse
+  half-octave log-magnitude spectra with a mean-removed cosine distance, which
+  separates every mode pair by ~2x the threshold and is stable across -O0..-O3
+  and -ffast-math.
@@ -7,12 +7,26 @@
 
 namespace {
 
-struct ModeSignature {
-    float rms = 0.0f;
-    float zeroCrossRate = 0.0f;
-    float sideRatio = 0.0f;
+// Coarse half-octave log-magnitude fingerprint used to assert that the modes and
+// scenes stay audibly distinct. Comparing band shape rather than hand-weighted
+// scalars (rms/zero-crossings/roughness) keeps the check tied to timbre and
+// independent of the shipping parameter defaults, which are a product decision
+// and change more often than the synthesis paths do.
+constexpr std::size_t kBandCount = 16;
+constexpr float kLowestBandHz = 60.0f;
+constexpr std::size_t kAnalysisStart = 1024;
+constexpr float kMagnitudeFloor = 1.0e-9f;
+
+// Minimum spectral distance required between any two modes, and between the
+// musical and extreme scenes. Measured worst-case separation at the shipping
+// defaults is ~0.117 for modes and ~0.150 for the scene pair, so this leaves
+// roughly a 2x margin rather than sitting inside the metric's own scatter.
+constexpr float kModeSeparation = 0.06f;
+constexpr float kSceneSeparation = 0.06f;
+
+struct Signature {
+    std::array<float, kBandCount> bands {};
     float peak = 0.0f;
-    float roughness = 0.0f;
 };
 
 bool nearlyEqual(const float a, const float b, const float epsilon = 1.0e-5f)
@@ -48,38 +62,95 @@ bool containsMidi(const downspout::gremlin::MidiMessage* events,
     return false;
 }
 
-ModeSignature measureRenderedSignature(const std::array<float, 4096>& left, const std::array<float, 4096>& right)
+// Goertzel magnitude for one bin over the analysis window.
+double bandMagnitude(const std::array<float, 4096>& left,
+                     const std::array<float, 4096>& right,
+                     const double frequencyHz,
+                     const double sampleRate)
 {
-    ModeSignature signature {};
-    int crossings = 0;
-    int samples = 0;
-    float energy = 0.0f;
-    float side = 0.0f;
-    float roughness = 0.0f;
-    float previous = 0.0f;
-    for (std::size_t i = 1024; i < left.size(); ++i)
+    const std::size_t count = left.size() - kAnalysisStart;
+    const double omega = 2.0 * 3.14159265358979323846 * frequencyHz / sampleRate;
+    const double coeff = 2.0 * std::cos(omega);
+
+    double q1 = 0.0;
+    double q2 = 0.0;
+    for (std::size_t i = 0; i < count; ++i)
     {
-        const float mono = 0.5f * (left[i] + right[i]);
-        if (samples > 0 && ((previous < 0.0f && mono >= 0.0f) || (previous > 0.0f && mono <= 0.0f)))
-            ++crossings;
-        if (samples > 0)
-            roughness += std::fabs(mono - previous);
-        previous = mono;
-
-        energy += mono * mono;
-        side += std::fabs(left[i] - right[i]);
+        const double sample = 0.5 * (static_cast<double>(left[kAnalysisStart + i])
+                                   + static_cast<double>(right[kAnalysisStart + i]));
+        const double q0 = coeff * q1 - q2 + sample;
+        q2 = q1;
+        q1 = q0;
+    }
+
+    const double power = q1 * q1 + q2 * q2 - coeff * q1 * q2;
+    return std::sqrt(std::max(0.0, power)) / static_cast<double>(count);
+}
+
+Signature measureRenderedSignature(const std::array<float, 4096>& left,
+                                   const std::array<float, 4096>& right,
+                                   const double sampleRate = 48000.0)
+{
+    Signature signature {};
+
+    for (std::size_t i = kAnalysisStart; i < left.size(); ++i)
         signature.peak = std::max(signature.peak, std::max(std::fabs(left[i]), std::fabs(right[i])));
-        ++samples;
+
+    for (std::size_t band = 0; band < kBandCount; ++band)
+    {
+        const double frequency = static_cast<double>(kLowestBandHz)
+                               * std::pow(2.0, static_cast<double>(band) * 0.5);
+        const double magnitude = frequency < sampleRate * 0.45
+                               ? bandMagnitude(left, right, frequency, sampleRate)
+                               : 0.0;
+        signature.bands[band] = static_cast<float>(std::log10(magnitude + kMagnitudeFloor));
     }
 
-    signature.rms = samples > 0 ? std::sqrt(energy / static_cast<float>(samples)) : 0.0f;
-    signature.zeroCrossRate = samples > 0 ? static_cast<float>(crossings) / static_cast<float>(samples) : 0.0f;
-    signature.sideRatio = energy > 0.0f ? side / (std::sqrt(energy) * static_cast<float>(samples)) : 0.0f;
-    signature.roughness = samples > 0 ? roughness / static_cast<float>(samples) : 0.0f;
     return signature;
 }
 
-ModeSignature renderModeSignature(const std::size_t mode)
+// Mean-removed cosine distance: 0 means identical band shape, larger means more
+// timbral difference. Removing the mean discards overall level so the check is
+// about spectrum rather than loudness.
+float spectralDistance(const Signature& a, const Signature& b)
+{
+    double meanA = 0.0;
+    double meanB = 0.0;
+    for (std::size_t i = 0; i < kBandCount; ++i)
+    {
+        meanA += a.bands[i];
+        meanB += b.bands[i];
+    }
+    meanA /= static_cast<double>(kBandCount);
+    meanB /= static_cast<double>(kBandCount);
+
+    double dot = 0.0;
+    double normA = 0.0;
+    double normB = 0.0;
+    for (std::size_t i = 0; i < kBandCount; ++i)
+    {
+        const double x = static_cast<double>(a.bands[i]) - meanA;
+        const double y = static_cast<double>(b.bands[i]) - meanB;
+        dot += x * y;
+        normA += x * x;
+        normB += y * y;
+    }
+
+    if (normA <= 0.0 || normB <= 0.0)
+        return 0.0f;
+
+    return static_cast<float>(1.0 - dot / std::sqrt(normA * normB));
+}
+
+void printSignature(const char* label, const std::size_t index, const Signature& signature)
+{
+    std::cerr << label << ' ' << index << " peak=" << signature.peak << " bands=[";
+    for (std::size_t i = 0; i < kBandCount; ++i)
+        std::cerr << signature.bands[i] << (i + 1 < kBandCount ? ", " : "");
+    std::cerr << "]\n";
+}
+
+Signature renderModeSignature(const std::size_t mode)
 {
     using downspout::gremlin::LiveParamId;
     using downspout::gremlin::MidiMessage;
@@ -102,7 +173,7 @@ ModeSignature renderModeSignature(const std::size_t mode)
     return measureRenderedSignature(left, right);
 }
 
-ModeSignature renderSceneSignature(const downspout::gremlin::SceneId scene)
+Signature renderSceneSignature(const downspout::gremlin::SceneId scene)
 {
     using downspout::gremlin::MidiMessage;
     using downspout::gremlin::Processor;
@@ -123,17 +194,6 @@ ModeSignature renderSceneSignature(const downspout::gremlin::SceneId scene)
     return measureRenderedSignature(left, right);
 }
 
-float signatureDistance(const ModeSignature& a, const ModeSignature& b)
-{
-    const float rmsA = std::max(a.rms, 1.0e-6f);
-    const float rmsB = std::max(b.rms, 1.0e-6f);
-    return std::fabs(std::log(rmsA / rmsB)) * 0.35f
-         + std::fabs(a.zeroCrossRate - b.zeroCrossRate) * 2.2f
-         + std::fabs(a.sideRatio - b.sideRatio) * 1.4f
-         + std::fabs(a.peak - b.peak) * 0.35f
-         + std::fabs(a.roughness - b.roughness) * 18.0f;
-}
-
 }  // namespace
 
 int main()
@@ -218,7 +278,7 @@ int main()
         require(modePeak > 0.005f, "gremlin mode should emit audio after note-on");
     }
 
-    std::array<ModeSignature, downspout::gremlin::kModeCount> signatures {};
+    std::array<Signature, downspout::gremlin::kModeCount> signatures {};
     for (std::size_t mode = 0; mode < downspout::gremlin::kModeCount; ++mode)
         signatures[mode] = renderModeSignature(mode);
 
@@ -230,35 +290,37 @@ int main()
         {
             if (mode == other)
                 continue;
-            const float distance = signatureDistance(signatures[mode], signatures[other]);
+            const float distance = spectralDistance(signatures[mode], signatures[other]);
             if (distance < nearest)
             {
                 nearest = distance;
                 nearestMode = other;
             }
         }
-        if (nearest <= 0.035f)
-            std::cerr << "nearest signature distance for mode " << mode << " was " << nearest
-                      << " against mode " << nearestMode << "\nmode " << mode
-                      << " rms=" << signatures[mode].rms
-                      << " zc=" << signatures[mode].zeroCrossRate
-                      << " side=" << signatures[mode].sideRatio
-                      << " peak=" << signatures[mode].peak
-                      << " rough=" << signatures[mode].roughness
-                      << "\nmode " << nearestMode
-                      << " rms=" << signatures[nearestMode].rms
-                      << " zc=" << signatures[nearestMode].zeroCrossRate
-                      << " side=" << signatures[nearestMode].sideRatio
-                      << " peak=" << signatures[nearestMode].peak
-                      << " rough=" << signatures[nearestMode].roughness << '\n';
-        require(nearest > 0.035f, "gremlin mode signatures should remain separated");
+        if (nearest <= kModeSeparation)
+        {
+            std::cerr << "nearest spectral distance for mode " << mode << " was " << nearest
+                      << " against mode " << nearestMode << " (threshold " << kModeSeparation << ")\n";
+            printSignature("mode", mode, signatures[mode]);
+            printSignature("mode", nearestMode, signatures[nearestMode]);
+        }
+        require(nearest > kModeSeparation, "gremlin mode signatures should remain separated");
     }
 
-    const ModeSignature musicalScene = renderSceneSignature(SceneId::melt);
-    const ModeSignature extremeScene = renderSceneSignature(SceneId::tunnel);
+    const Signature musicalScene = renderSceneSignature(SceneId::melt);
+    const Signature extremeScene = renderSceneSignature(SceneId::tunnel);
     require(musicalScene.peak > 0.005f, "gremlin musical scene should emit audio");
     require(extremeScene.peak > 0.005f, "gremlin extreme scene should emit audio");
-    require(signatureDistance(musicalScene, extremeScene) > 0.08f,
+
+    const float sceneDistance = spectralDistance(musicalScene, extremeScene);
+    if (sceneDistance <= kSceneSeparation)
+    {
+        std::cerr << "musical/extreme scene spectral distance was " << sceneDistance
+                  << " (threshold " << kSceneSeparation << ")\n";
+        printSignature("scene", 0, musicalScene);
+        printSignature("scene", 1, extremeScene);
+    }
+    require(sceneDistance > kSceneSeparation,
             "gremlin musical and extreme scenes should remain audibly separated");
 
     float monoOnly[128] {};