@mcptoolshop/claude-sfx 1.1.0 → 1.2.0

package/dist/verbs.js

@@ -1,8 +1,12 @@
 /**
  * Verb generation engine — profile-driven.
  * Reads synthesis parameters from a Profile, applies modifiers, generates audio.
+ *
+ * Architecture: multi-note motifs in A major pentatonic with constrained variation.
+ * Each verb has 3 variants. Micro-jitter keeps sounds alive without breaking identity.
  */
 import { SAMPLE_RATE, generateTone, generateWhoosh, mixBuffers, limitLoudness, } from "./synth.js";
+import { SCALE, scaleStepDown } from "./profiles.js";
 export const VERB_LABELS = {
     intake: "Intake",
     transform: "Transform",
@@ -22,211 +26,315 @@ export const VERB_DESCRIPTIONS = {
     sync: "git push / pull / deploy",
 };
 export const ALL_VERBS = [
-    "intake",
-    "transform",
-    "commit",
-    "navigate",
-    "execute",
-    "move",
-    "sync",
+    "intake", "transform", "commit", "navigate", "execute", "move", "sync",
 ];
-// --- Status modifier functions (tone-based) ---
-function applyToneStatus(params, status) {
-    const p = { ...params };
-    switch (status) {
-        case "ok":
-            p.harmonicGain = 0.15;
-            break;
-        case "err":
-            p.frequency *= 0.7;
-            if (p.frequencyEnd)
-                p.frequencyEnd *= 0.7;
-            p.detune = 3;
-            p.duration *= 1.3;
-            break;
-        case "warn":
-            p.tremoloRate = 8;
-            p.tremoloDepth = 0.5;
-            break;
+// --- Variant selection ---
+function pickVariant(variants, override) {
+    if (override !== undefined && override >= 0 && override < variants.length) {
+        return variants[override];
     }
-    return p;
+    return variants[Math.floor(Math.random() * variants.length)];
+}
+// --- Micro-jitter (constrained variation) ---
+/**
+ * Apply micro-jitter to a note to reduce listener fatigue.
+ * Constraints: ±5 cents pitch, ±6% duration, ±4ms onset, ±0.8 dB gain.
+ * Identity (register, contour, timbre) is preserved.
+ */
+function jitterNote(note) {
+    const n = { ...note, envelope: { ...note.envelope } };
+    // Pitch drift: ±5 cents (1 cent ≈ 0.058% frequency change)
+    const centsDrift = (Math.random() - 0.5) * 10;
+    n.frequency *= Math.pow(2, centsDrift / 1200);
+    // Duration jitter: ±6%
+    n.duration *= 1 + (Math.random() - 0.5) * 0.12;
+    // Onset jitter: ±4ms
+    n.offsetMs = Math.max(0, n.offsetMs + (Math.random() - 0.5) * 8);
+    // Gain drift: ±0.8 dB (≈ ±9.6%)
+    n.gain *= 1 + (Math.random() - 0.5) * 0.19;
+    return n;
+}
+// --- Note rendering ---
+/** Render a single MotifNote into a PCM buffer with optional waveform blending. */
+function renderNote(note, masterGain) {
+    const gain = note.gain * masterGain;
+    const offsetSamples = Math.max(0, Math.floor((note.offsetMs / 1000) * SAMPLE_RATE));
+    const baseParams = {
+        waveform: note.waveform,
+        frequency: note.frequency,
+        duration: note.duration,
+        envelope: { ...note.envelope },
+        gain,
+        fmRatio: note.fmRatio,
+        fmDepth: note.fmDepth,
+        harmonicGain: note.harmonicGain,
+        tremoloRate: note.tremoloRate,
+        tremoloDepth: note.tremoloDepth,
+        detune: note.detune,
+    };
+    let buffer;
+    if (note.blendWaveform && note.blendAmount && note.blendAmount > 0) {
+        const primary = generateTone({ ...baseParams, gain: gain * (1 - note.blendAmount) });
+        const blend = generateTone({ ...baseParams, waveform: note.blendWaveform, gain: gain * note.blendAmount });
+        buffer = mixBuffers([primary, blend]);
+    }
+    else {
+        buffer = generateTone(baseParams);
+    }
+    return { buffer, offsetSamples };
+}
+/** Render a complete motif variant into a single buffer. */
+function renderMotif(variant, masterGain, applyJitter = true) {
+    const notes = applyJitter ? variant.notes.map(jitterNote) : variant.notes;
+    const rendered = notes.map(n => renderNote(n, masterGain));
+    // Calculate total buffer length
+    let maxLen = 0;
+    for (const { buffer, offsetSamples } of rendered) {
+        maxLen = Math.max(maxLen, offsetSamples + buffer.length);
+    }
+    const output = new Float64Array(maxLen);
+    // Mix all notes at their offsets
+    for (const { buffer, offsetSamples } of rendered) {
+        for (let i = 0; i < buffer.length; i++) {
+            if (offsetSamples + i < output.length) {
+                output[offsetSamples + i] += buffer[i];
+            }
+        }
+    }
+    // Add noise transient if present (e.g., execute verb percussive onset)
+    if (variant.noiseTransient) {
+        const nt = variant.noiseTransient;
+        const noiseBuffer = generateWhoosh({
+            duration: nt.duration,
+            freqStart: nt.freqStart,
+            freqEnd: nt.freqEnd,
+            bandwidth: nt.bandwidth,
+            envelope: { attack: 0.001, decay: nt.duration * 0.4, sustain: 0.0, release: nt.duration * 0.3 },
+            gain: nt.gain * masterGain,
+        });
+        // Noise at the very start of the buffer
+        for (let i = 0; i < noiseBuffer.length && i < output.length; i++) {
+            output[i] += noiseBuffer[i];
+        }
+    }
+    return output;
+}
+/** Render a whoosh anchor variant into a buffer. */
+function renderAnchor(anchor, masterGain, applyJitter = true) {
+    // Reuse motif rendering for the tonal anchor notes
+    return renderMotif({ notes: anchor.notes }, masterGain, applyJitter);
+}
+// --- Musical modifiers (motif-based) ---
+/**
+ * Apply status modifier to a motif variant.
+ * ok: add quiet fifth above strongest tone.
+ * warn: gentle tremolo (5.5 Hz / 0.22 depth).
+ * err: final note drops one scale degree, detune ±2 Hz, longer release.
+ */
+function applyMotifStatus(variant, status) {
+    if (status === "ok") {
+        const notes = [...variant.notes];
+        const lastNote = notes[notes.length - 1];
+        // Add a quiet perfect fifth above the last note
+        notes.push({
+            ...lastNote,
+            frequency: lastNote.frequency * 1.5,
+            gain: lastNote.gain * 0.35,
+            harmonicGain: undefined,
+            fmRatio: undefined,
+            fmDepth: undefined,
+        });
+        return { ...variant, notes };
+    }
+    if (status === "warn") {
+        return {
+            ...variant,
+            notes: variant.notes.map(n => ({
+                ...n,
+                tremoloRate: 5.5,
+                tremoloDepth: 0.22,
+            })),
+        };
+    }
+    if (status === "err") {
+        const notes = variant.notes.map((n, i) => {
+            const isLast = i === variant.notes.length - 1;
+            return {
+                ...n,
+                // Final note drops one scale degree
+                frequency: isLast ? scaleStepDown(n.frequency) : n.frequency,
+                detune: 2,
+                duration: n.duration * 1.15,
+                envelope: { ...n.envelope, release: n.envelope.release * 1.25 },
+                // Reduce top harmonic by 20%
+                harmonicGain: n.harmonicGain ? n.harmonicGain * 0.8 : undefined,
+            };
+        });
+        return { ...variant, notes };
+    }
+    return variant;
 }
-function applyToneScope(params, scope) {
+/**
+ * Apply scope modifier to a motif variant.
+ * remote: slightly farther away — longer attack/release, quieter.
+ */
+function applyMotifScope(variant, scope) {
     if (scope === "remote") {
-        const p = { ...params };
-        p.envelope = { ...p.envelope, release: p.envelope.release * 2.5 };
-        p.duration *= 1.2;
-        return p;
+        return {
+            ...variant,
+            notes: variant.notes.map(n => ({
+                ...n,
+                envelope: {
+                    ...n.envelope,
+                    attack: n.envelope.attack * 1.25,
+                    release: n.envelope.release * 1.5,
+                },
+                gain: n.gain * 0.92,
+            })),
+        };
     }
-    return params;
+    return variant;
 }
-// --- Status modifier functions (whoosh-based) ---
+/**
+ * Apply streak intensity (1–5) to a motif variant.
+ * Progression: base → harmonic → brighter interval → FM shimmer → richer tail.
+ * Gain change kept within ~+2.5 dB total.
+ */
+function applyMotifIntensity(variant, intensity) {
+    if (intensity <= 1)
+        return variant;
+    return {
+        ...variant,
+        notes: variant.notes.map(n => {
+            const note = { ...n, envelope: { ...n.envelope } };
+            if (intensity >= 2) {
+                // Add quiet harmonic
+                note.harmonicGain = Math.max(note.harmonicGain ?? 0, 0.06 + (intensity - 2) * 0.03);
+            }
+            if (intensity >= 3) {
+                // Slightly brighter (lift pitch within scale tolerance)
+                note.frequency *= 1 + (intensity - 2) * 0.015;
+            }
+            if (intensity >= 4) {
+                // Add subtle FM shimmer
+                note.fmRatio = note.fmRatio ?? 2;
+                note.fmDepth = Math.max(note.fmDepth ?? 0, 6 + (intensity - 4) * 5);
+            }
+            if (intensity >= 5) {
+                // Slightly longer tail + tiny gain lift
+                note.envelope.release *= 1.2;
+                note.gain = Math.min(note.gain * 1.06, 1.0);
+            }
+            return note;
+        }),
+    };
+}
+/**
+ * Apply error escalation (1–5) to a motif variant.
+ * Progression: base → lower register → detune → tremolo → heavy weight.
+ */
+function applyMotifEscalation(variant, escalation) {
+    if (escalation <= 1)
+        return variant;
+    return {
+        ...variant,
+        notes: variant.notes.map(n => {
+            const note = { ...n, envelope: { ...n.envelope } };
+            if (escalation >= 2) {
+                // Lower register
+                note.frequency = scaleStepDown(note.frequency);
+            }
+            if (escalation >= 3) {
+                // Slight detune
+                note.detune = (note.detune ?? 0) + 1.5;
+            }
+            if (escalation >= 4) {
+                // Soft tremolo/pulse
+                note.tremoloRate = 4.5;
+                note.tremoloDepth = 0.30;
+                note.envelope.decay *= 1.15;
+            }
+            if (escalation >= 5) {
+                // Longer decay, heavier instability
+                note.detune = (note.detune ?? 0) + 1.5;
+                note.tremoloDepth = 0.45;
+                note.envelope.release *= 1.5;
+                note.gain *= 0.95;
+            }
+            return note;
+        }),
+    };
+}
+// --- Musical modifiers (whoosh-based) ---
 function applyWhooshStatus(params, status) {
-    const p = { ...params };
+    const p = { ...params, envelope: { ...params.envelope } };
     switch (status) {
         case "ok":
-            p.freqEnd = Math.min(p.freqEnd * 1.2, 6000);
+            p.freqEnd = Math.min(p.freqEnd * 1.15, 5000);
             break;
         case "err":
-            p.freqStart *= 0.6;
-            p.freqEnd *= 0.6;
-            p.duration *= 1.3;
-            p.bandwidth = 1.2;
+            p.freqStart = scaleStepDown(p.freqStart);
+            p.freqEnd *= 0.7;
+            p.duration *= 1.15;
+            p.bandwidth = Math.min(p.bandwidth * 1.3, 1.5);
             break;
         case "warn":
-            p.duration *= 0.8;
-            p.envelope = { ...p.envelope, attack: 0.01, release: 0.03 };
+            p.duration *= 0.85;
+            p.envelope.attack *= 0.5;
+            p.envelope.release *= 0.7;
             break;
     }
     return p;
 }
 function applyWhooshScope(params, scope) {
     if (scope === "remote") {
-        const p = { ...params };
-        p.duration *= 1.3;
-        p.envelope = { ...p.envelope, release: p.envelope.release * 2 };
+        const p = { ...params, envelope: { ...params.envelope } };
+        p.envelope.attack *= 1.25;
+        p.envelope.release *= 1.5;
+        p.duration *= 1.15;
+        p.gain *= 0.92;
         return p;
     }
     return params;
 }
-// --- Intensity modifiers (streak-driven layering) ---
-/**
- * Apply streak intensity to tone params.
- * Level 1: clean (no change)
- * Level 2: subtle octave harmonic
- * Level 3: harmonic + slight frequency lift
- * Level 4: richer harmonics + FM shimmer
- * Level 5: full chord feel — harmonics + FM + slight gain boost
- */
-function applyToneIntensity(params, intensity) {
-    if (intensity <= 1)
-        return params;
-    const p = { ...params };
-    if (intensity >= 2) {
-        p.harmonicGain = Math.max(p.harmonicGain ?? 0, 0.08 + (intensity - 2) * 0.04);
-    }
-    if (intensity >= 3) {
-        // Slight frequency lift — sounds "brighter" with momentum
-        p.frequency *= 1 + (intensity - 2) * 0.02;
-        if (p.frequencyEnd)
-            p.frequencyEnd *= 1 + (intensity - 2) * 0.02;
-    }
-    if (intensity >= 4) {
-        // Add FM shimmer for texture
-        p.fmRatio = p.fmRatio ?? 2;
-        p.fmDepth = Math.max(p.fmDepth ?? 0, 10 + (intensity - 4) * 8);
-    }
-    if (intensity >= 5) {
-        // Subtle gain boost — session is cooking
-        p.gain = Math.min(p.gain * 1.1, 0.9);
-    }
-    return p;
-}
 function applyWhooshIntensity(params, intensity) {
     if (intensity <= 1)
         return params;
-    const p = { ...params };
+    const p = { ...params, envelope: { ...params.envelope } };
     if (intensity >= 2) {
-        // Wider sweep range
-        p.freqEnd = Math.min(p.freqEnd * (1 + (intensity - 1) * 0.08), 8000);
+        p.freqEnd = Math.min(p.freqEnd * (1 + (intensity - 1) * 0.06), 6000);
     }
     if (intensity >= 3) {
-        // Tighter bandwidth = more defined whoosh
-        p.bandwidth = Math.max(p.bandwidth * 0.85, 0.3);
+        p.bandwidth = Math.max(p.bandwidth * 0.88, 0.3);
     }
     if (intensity >= 4) {
-        // Slightly longer — more dramatic
-        p.duration *= 1.05;
-    }
-    return p;
-}
-// --- Error escalation modifiers ---
-/**
- * Progressive error escalation for tones.
- * Level 1: standard error (same as status:err)
- * Level 2: deeper frequency drop + more detuning
- * Level 3: add tremolo (something is wrong)
- * Level 4: wider detuning + slower tremolo (stuck)
- * Level 5: max urgency — deep drop, heavy tremolo, long decay
- */
-function applyToneEscalation(params, escalation) {
-    if (escalation <= 1)
-        return params;
-    const p = { ...params };
-    if (escalation >= 2) {
-        p.frequency *= 0.9;
-        if (p.frequencyEnd)
-            p.frequencyEnd *= 0.9;
-        p.detune = (p.detune ?? 0) + 2;
-    }
-    if (escalation >= 3) {
-        p.tremoloRate = 6;
-        p.tremoloDepth = 0.4;
-    }
-    if (escalation >= 4) {
-        p.detune = (p.detune ?? 0) + 3;
-        p.tremoloRate = 4;
-        p.tremoloDepth = 0.6;
-        p.duration *= 1.15;
-    }
-    if (escalation >= 5) {
-        p.frequency *= 0.85;
-        if (p.frequencyEnd)
-            p.frequencyEnd *= 0.85;
-        p.tremoloDepth = 0.75;
-        p.duration *= 1.2;
-        p.envelope = { ...p.envelope, release: p.envelope.release * 2 };
+        p.duration *= 1.04;
     }
     return p;
 }
 function applyWhooshEscalation(params, escalation) {
     if (escalation <= 1)
         return params;
-    const p = { ...params };
+    const p = { ...params, envelope: { ...params.envelope } };
     if (escalation >= 2) {
-        p.freqStart *= 0.7;
-        p.freqEnd *= 0.7;
+        p.freqStart *= 0.75;
+        p.freqEnd *= 0.75;
     }
     if (escalation >= 3) {
-        p.bandwidth = Math.min(p.bandwidth * 1.5, 2);
-        p.duration *= 1.2;
+        p.bandwidth = Math.min(p.bandwidth * 1.4, 2);
+        p.duration *= 1.15;
     }
     if (escalation >= 4) {
-        p.duration *= 1.2;
-        p.envelope = { ...p.envelope, release: p.envelope.release * 1.5 };
+        p.envelope.release *= 1.4;
+        p.duration *= 1.1;
     }
     if (escalation >= 5) {
-        p.freqStart *= 0.8;
-        p.freqEnd *= 0.8;
-        p.duration *= 1.15;
+        p.freqStart *= 0.85;
+        p.freqEnd *= 0.85;
+        p.duration *= 1.08;
     }
     return p;
 }
-// --- Config → Params conversion ---
-function toneConfigToParams(cfg) {
-    return {
-        waveform: cfg.waveform,
-        frequency: cfg.frequency,
-        frequencyEnd: cfg.frequencyEnd,
-        duration: cfg.duration,
-        envelope: { ...cfg.envelope },
-        gain: cfg.gain,
-        fmRatio: cfg.fmRatio,
-        fmDepth: cfg.fmDepth,
-        harmonicGain: cfg.harmonicGain,
-    };
-}
-function whooshConfigToParams(cfg, direction) {
-    const freqPair = direction === "down" ? cfg.freqDown : cfg.freqUp;
-    return {
-        duration: cfg.duration,
-        freqStart: freqPair[0],
-        freqEnd: freqPair[1],
-        bandwidth: cfg.bandwidth,
-        envelope: { ...cfg.envelope },
-        gain: cfg.gain,
-    };
-}
 // --- Main generation ---
 /** Generate a verb sound using the given profile. */
 export function generateVerb(profile, verb, options = {}) {
@@ -234,10 +342,18 @@ export function generateVerb(profile, verb, options = {}) {
     if (!cfg) {
         throw new Error(`Profile "${profile.name}" has no config for verb "${verb}"`);
     }
-    // Whoosh-based verbs
+    // ── Whoosh-based verbs (move, sync) ─────────────────────────
     if (cfg.type === "whoosh") {
         const dir = options.direction ?? "up";
-        let wp = whooshConfigToParams(cfg, dir);
+        const freqPair = dir === "down" ? cfg.freqDown : cfg.freqUp;
+        let wp = {
+            duration: cfg.duration,
+            freqStart: freqPair[0],
+            freqEnd: freqPair[1],
+            bandwidth: cfg.bandwidth,
+            envelope: { ...cfg.envelope },
+            gain: cfg.gain,
+        };
         if (options.status)
             wp = applyWhooshStatus(wp, options.status);
         if (options.scope)
@@ -246,64 +362,66 @@ export function generateVerb(profile, verb, options = {}) {
             wp = applyWhooshIntensity(wp, options.intensity);
         if (options.escalation)
             wp = applyWhooshEscalation(wp, options.escalation);
-        const whoosh = generateWhoosh(wp);
-        // Tonal anchor (sync)
-        if (cfg.tonalAnchor) {
-            const anchorFreqs = dir === "down" ? cfg.tonalAnchor.freqDown : cfg.tonalAnchor.freqUp;
-            const anchor = generateTone({
-                waveform: "sine",
-                frequency: anchorFreqs[0],
-                frequencyEnd: anchorFreqs[1],
-                duration: wp.duration,
-                envelope: { ...cfg.tonalAnchor.envelope },
-                gain: cfg.tonalAnchor.gain,
-            });
-            return limitLoudness(mixBuffers([whoosh, anchor]));
+        const whooshBuf = generateWhoosh(wp);
+        // Tonal anchor variant
+        if (cfg.anchorVariants && cfg.anchorVariants.length > 0) {
+            let anchor = pickVariant(cfg.anchorVariants, options.variantIndex);
+            // Apply motif modifiers to anchor notes too
+            let anchorMotif = { notes: anchor.notes };
+            if (options.status)
+                anchorMotif = applyMotifStatus(anchorMotif, options.status);
+            if (options.scope)
+                anchorMotif = applyMotifScope(anchorMotif, options.scope);
+            if (options.intensity)
+                anchorMotif = applyMotifIntensity(anchorMotif, options.intensity);
+            if (options.escalation)
+                anchorMotif = applyMotifEscalation(anchorMotif, options.escalation);
+            const anchorBuf = renderMotif(anchorMotif, cfg.gain);
+            // Mix: align to same start, extend to longest
+            const maxLen = Math.max(whooshBuf.length, anchorBuf.length);
+            const whooshPadded = new Float64Array(maxLen);
+            whooshPadded.set(whooshBuf, 0);
+            const anchorPadded = new Float64Array(maxLen);
+            anchorPadded.set(anchorBuf, 0);
+            return limitLoudness(mixBuffers([whooshPadded, anchorPadded]));
         }
-        return limitLoudness(whoosh);
+        return limitLoudness(whooshBuf);
     }
-    // Tone-based verbs
-    let params = toneConfigToParams(cfg);
+    // ── Motif-based verbs (intake, transform, commit, navigate, execute) ──
+    let variant = pickVariant(cfg.variants, options.variantIndex);
     if (options.status)
-        params = applyToneStatus(params, options.status);
+        variant = applyMotifStatus(variant, options.status);
     if (options.scope)
-        params = applyToneScope(params, options.scope);
+        variant = applyMotifScope(variant, options.scope);
     if (options.intensity)
-        params = applyToneIntensity(params, options.intensity);
+        variant = applyMotifIntensity(variant, options.intensity);
     if (options.escalation)
-        params = applyToneEscalation(params, options.escalation);
-    const primary = generateTone(params);
-    // Noise burst layer (execute)
-    if (cfg.noiseBurst) {
-        const noise = generateTone({
-            waveform: "noise",
-            frequency: 0,
-            duration: cfg.noiseBurst.duration,
-            envelope: { attack: 0.002, decay: 0.03, sustain: 0.0, release: 0.005 },
-            gain: cfg.noiseBurst.gain,
-        });
-        return limitLoudness(mixBuffers([primary, noise]));
-    }
-    return limitLoudness(primary);
+        variant = applyMotifEscalation(variant, options.escalation);
+    const buffer = renderMotif(variant, cfg.gain);
+    return limitLoudness(buffer);
 }
 // --- Session sounds ---
-function generateChime(chime) {
-    const tone1 = generateTone({
-        waveform: chime.tone1.waveform,
-        frequency: chime.tone1.frequency,
-        duration: chime.tone1.duration,
-        envelope: { ...chime.tone1.envelope },
-        gain: chime.tone1.gain,
-        harmonicGain: chime.tone1.harmonicGain,
-    });
-    const tone2 = generateTone({
-        waveform: chime.tone2.waveform,
-        frequency: chime.tone2.frequency,
-        duration: chime.tone2.duration,
-        envelope: { ...chime.tone2.envelope },
-        gain: chime.tone2.gain,
-        harmonicGain: chime.tone2.harmonicGain,
-    });
+/** Render a chime tone with optional waveform blending. */
+function renderChimeTone(tone, extraGain = 1.0) {
+    const gain = tone.gain * extraGain;
+    const params = {
+        waveform: tone.waveform,
+        frequency: tone.frequency,
+        duration: tone.duration,
+        envelope: { ...tone.envelope },
+        gain,
+        harmonicGain: tone.harmonicGain,
+    };
+    if (tone.blendWaveform && tone.blendAmount && tone.blendAmount > 0) {
+        const primary = generateTone({ ...params, gain: gain * (1 - tone.blendAmount) });
+        const blend = generateTone({ ...params, waveform: tone.blendWaveform, gain: gain * tone.blendAmount });
+        return mixBuffers([primary, blend]);
+    }
+    return generateTone(params);
+}
+function generateChime(chime, gainMul = 1.0) {
+    const tone1 = renderChimeTone(chime.tone1, gainMul);
+    const tone2 = renderChimeTone(chime.tone2, gainMul);
     const offset = Math.floor(chime.staggerSeconds * SAMPLE_RATE);
     const total = new Float64Array(Math.max(tone1.length, offset + tone2.length));
     total.set(tone1, 0);
@@ -322,49 +440,54 @@ export function generateSessionEnd(profile) {
 }
 /**
  * Generate an outcome-aware session end sound.
- *
- * Great session (ratio >= 0.8, 5+ plays): triumphant ascending chord
- * Good session (ratio >= 0.6): standard descending chime (existing behavior)
- * Rough session (ratio < 0.6): muted, lower, shorter resolution
- * Empty session (< 5 plays): standard chime (not enough data)
+ * Great (ratio >= 0.8, 5+ plays): A4 → C#5 → E5 ascending fanfare.
+ * Normal: standard descending chime.
+ * Rough (ratio < 0.6): muted, lower, shorter resolution.
+ * Empty (< 5 plays): standard chime.
  */
 export function generateSessionEndWithOutcome(profile, outcome) {
-    // Not enough data — use standard chime
     if (outcome.totalPlays < 5) {
         return generateChime(profile.sessionEnd);
     }
     if (outcome.successRatio >= 0.8) {
-        // Triumphant: 3-note ascending chord (C5 → E5 → G5) with harmonics
         return generateFanfare(profile);
     }
     if (outcome.successRatio < 0.6) {
-        // Rough session: lower, shorter, muted resolution
         return generateMutedEnd(profile);
     }
-    // Normal session: standard chime
     return generateChime(profile.sessionEnd);
 }
-/** Triumphant 3-note ascending fanfare. */
+/** A4 → C#5 → E5 ascending fanfare — the big win. */
 function generateFanfare(profile) {
     const waveform = profile.sessionEnd.tone1.waveform;
-    // C5 → E5 → G5 (major triad ascending)
-    const notes = [523, 659, 784];
+    const blendWave = profile.sessionEnd.tone1.blendWaveform;
+    const blendAmt = profile.sessionEnd.tone1.blendAmount ?? 0;
+    // A major triad ascending: A4 → C#5 → E5
+    const notes = [SCALE.A4, SCALE.Cs5, SCALE.E5];
     const buffers = [];
     for (let i = 0; i < notes.length; i++) {
         const isLast = i === notes.length - 1;
-        buffers.push(generateTone({
+        const params = {
             waveform,
             frequency: notes[i],
-            duration: isLast ? 0.35 : 0.18,
+            duration: isLast ? 0.30 : 0.15,
             envelope: {
-                attack: 0.01,
-                decay: isLast ? 0.12 : 0.06,
-                sustain: isLast ? 0.35 : 0.25,
-                release: isLast ? 0.12 : 0.05,
+                attack: 0.008,
+                decay: isLast ? 0.10 : 0.05,
+                sustain: isLast ? 0.30 : 0.20,
+                release: isLast ? 0.10 : 0.04,
             },
-            gain: isLast ? 0.55 : 0.45,
-            harmonicGain: isLast ? 0.15 : 0.08,
-        }));
+            gain: isLast ? 0.22 : 0.18,
+            harmonicGain: isLast ? 0.12 : 0.06,
+        };
+        if (blendWave && blendAmt > 0) {
+            const primary = generateTone({ ...params, gain: params.gain * (1 - blendAmt) });
+            const blend = generateTone({ ...params, waveform: blendWave, gain: params.gain * blendAmt });
+            buffers.push(mixBuffers([primary, blend]));
+        }
+        else {
+            buffers.push(generateTone(params));
+        }
     }
     // Stagger: each note starts 70ms after the previous
     const stagger = Math.floor(0.07 * SAMPLE_RATE);
@@ -381,38 +504,21 @@ function generateFanfare(profile) {
     }
     return limitLoudness(total);
 }
-/** Muted session end — lower pitch, shorter, subdued. */
+/** Muted session end — same contour, octave lower, quieter. */
 function generateMutedEnd(profile) {
     const cfg = profile.sessionEnd;
-    const tone1 = generateTone({
-        waveform: cfg.tone1.waveform,
-        frequency: cfg.tone1.frequency * 0.8,
-        duration: cfg.tone1.duration * 0.8,
-        envelope: { ...cfg.tone1.envelope, release: cfg.tone1.envelope.release * 0.6 },
-        gain: cfg.tone1.gain * 0.7,
-    });
-    const tone2 = generateTone({
-        waveform: cfg.tone2.waveform,
-        frequency: cfg.tone2.frequency * 0.75,
-        duration: cfg.tone2.duration * 0.7,
-        envelope: { ...cfg.tone2.envelope, release: cfg.tone2.envelope.release * 0.5 },
-        gain: cfg.tone2.gain * 0.6,
-    });
-    const offset = Math.floor(cfg.staggerSeconds * SAMPLE_RATE);
-    const total = new Float64Array(Math.max(tone1.length, offset + tone2.length));
-    total.set(tone1, 0);
-    for (let i = 0; i < tone2.length; i++) {
-        if (offset + i < total.length) {
-            total[offset + i] += tone2[i];
-        }
-    }
-    return limitLoudness(total);
+    // One octave lower, 60% gain
+    const mutedChime = {
+        tone1: { ...cfg.tone1, frequency: cfg.tone1.frequency * 0.5, gain: cfg.tone1.gain * 0.6 },
+        tone2: { ...cfg.tone2, frequency: cfg.tone2.frequency * 0.5, gain: cfg.tone2.gain * 0.6 },
+        staggerSeconds: cfg.staggerSeconds,
+    };
+    return generateChime(mutedChime);
 }
 // --- Ambient (long-running thinking) ---
 /** Generate a single chunk of the ambient thinking drone. */
 export function generateAmbientChunk(profile) {
     const cfg = profile.ambient;
-    // Low drone with very gentle fade in/out to allow seamless looping
     return generateTone({
         waveform: cfg.droneWaveform,
         frequency: cfg.droneFreq,
@@ -424,29 +530,28 @@ export function generateAmbientChunk(profile) {
             release: 0.3,
         },
         gain: cfg.droneGain,
-        // Subtle tremolo gives the drone "life" instead of a dead flat tone
         tremoloRate: 0.5,
         tremoloDepth: 0.15,
     });
 }
-/** Generate the resolution stinger (two ascending notes). */
+/** Generate the resolution stinger (two ascending notes, A major). */
 export function generateAmbientResolve(profile) {
     const cfg = profile.ambient;
     const note1 = generateTone({
         waveform: cfg.resolveWaveform,
         frequency: cfg.resolveNote1,
         duration: cfg.resolveDuration,
-        envelope: { attack: 0.008, decay: 0.06, sustain: 0.25, release: 0.04 },
+        envelope: { attack: 0.006, decay: 0.05, sustain: 0.20, release: 0.04 },
         gain: cfg.resolveGain,
-        harmonicGain: 0.1,
+        harmonicGain: 0.08,
     });
     const note2 = generateTone({
         waveform: cfg.resolveWaveform,
         frequency: cfg.resolveNote2,
         duration: cfg.resolveDuration * 1.3,
-        envelope: { attack: 0.008, decay: 0.08, sustain: 0.25, release: 0.06 },
+        envelope: { attack: 0.006, decay: 0.07, sustain: 0.20, release: 0.05 },
         gain: cfg.resolveGain * 0.9,
-        harmonicGain: 0.1,
+        harmonicGain: 0.08,
     });
     const offset = Math.floor(cfg.resolveDuration * 0.6 * SAMPLE_RATE);
     const total = new Float64Array(offset + note2.length);