livepilot 1.10.5 → 1.10.7

package/mcp_server/sample_engine/analyzer.py

@@ -188,14 +188,30 @@ def build_profile_from_filename(
     source: str = "filesystem",
     duration_seconds: float = 0.0,
 ) -> SampleProfile:
-    """Build a SampleProfile from filename metadata only (no spectral analysis).
-
-    This is the fallback when M4L bridge is unavailable.
+    """Build a SampleProfile from filename metadata + offline spectral
+    analysis (BUG-B49 fix).
+
+    Filename still supplies key / bpm / material-type hints when
+    present, but we now ALSO open the audio file via soundfile and
+    compute:
+        - duration_seconds (exact)
+        - frequency_center / frequency_spread (FFT-based centroid)
+        - brightness (high-band energy ratio)
+        - transient_density (RMS-gradient peak count)
+        - has_clear_downbeat (peak-interval consistency)
+    These used to be zeros regardless of file contents — downstream
+    critics had no real data.
+
+    If soundfile isn't available or the file can't be decoded, we
+    gracefully fall back to the filename-only path (legacy behavior).
     """
     name = os.path.splitext(os.path.basename(file_path))[0]
     metadata = parse_filename_metadata(file_path)
     material = classify_material_from_name(name)
 
+    # Offline spectral analysis — best-effort, never raises.
+    spectral = _analyze_audio_file(file_path)
+
     profile = SampleProfile(
         source=source,
         file_path=file_path,
@@ -206,7 +222,14 @@ def build_profile_from_filename(
         bpm_confidence=0.5 if metadata.get("bpm") else 0.0,
         material_type=material,
         material_confidence=0.4,  # filename-only is low confidence
-        duration_seconds=duration_seconds,
+        duration_seconds=(
+            spectral.get("duration_seconds") or duration_seconds
+        ),
+        frequency_center=spectral.get("frequency_center", 0.0),
+        frequency_spread=spectral.get("frequency_spread", 0.0),
+        brightness=spectral.get("brightness", 0.0),
+        transient_density=spectral.get("transient_density", 0.0),
+        has_clear_downbeat=spectral.get("has_clear_downbeat", False),
     )
 
     profile.suggested_mode = suggest_simpler_mode(profile)
@@ -214,3 +237,107 @@ def build_profile_from_filename(
     profile.suggested_warp_mode = suggest_warp_mode(profile)
 
     return profile
+
+
+def _analyze_audio_file(file_path: str) -> dict:
+    """Read an audio file and compute lightweight spectral/temporal
+    features via numpy. Returns {} if the file can't be decoded.
+
+    Uses soundfile (already a dependency) + numpy FFT — no librosa
+    required. Falls back cleanly so file-not-found / unsupported
+    format doesn't break the analyzer.
+    """
+    try:
+        import soundfile as sf
+        import numpy as np
+    except ImportError:
+        return {}
+
+    if not file_path or not os.path.exists(file_path):
+        return {}
+
+    try:
+        data, samplerate = sf.read(file_path, dtype="float32")
+    except Exception:
+        return {}
+
+    # Downmix to mono
+    if data.ndim > 1:
+        data = data.mean(axis=1)
+    if data.size == 0 or samplerate <= 0:
+        return {}
+
+    duration = float(data.size) / float(samplerate)
+
+    # Spectral centroid via magnitude-weighted frequency average.
+    # Use a Welch-style average over ~50ms windows to stabilize.
+    win_len = max(1024, int(samplerate * 0.05))
+    hop = win_len // 2
+    centroids: list[float] = []
+    spreads: list[float] = []
+    frames = range(0, max(len(data) - win_len, 1), hop)
+    for start in frames:
+        frame = data[start:start + win_len]
+        if len(frame) < 32:
+            continue
+        # Hann-window + FFT
+        mags = np.abs(np.fft.rfft(frame * np.hanning(len(frame))))
+        total = mags.sum()
+        if total <= 0:
+            continue
+        freqs = np.linspace(0, samplerate / 2, len(mags))
+        c = float((mags * freqs).sum() / total)
+        centroids.append(c)
+        # Spectral spread = sqrt(sum(mags * (freqs - c)**2) / total)
+        s = float(np.sqrt(((mags * (freqs - c) ** 2).sum()) / total))
+        spreads.append(s)
+
+    if not centroids:
+        return {"duration_seconds": duration}
+
+    frequency_center = float(np.mean(centroids))
+    frequency_spread = float(np.mean(spreads))
+    # Brightness: fraction of energy above 4kHz
+    # Use a single FFT on the whole signal for this (cheap)
+    full_mags = np.abs(np.fft.rfft(data * np.hanning(len(data))))
+    full_freqs = np.linspace(0, samplerate / 2, len(full_mags))
+    total_energy = full_mags.sum() or 1.0
+    high_energy = full_mags[full_freqs >= 4000].sum()
+    brightness = float(high_energy / total_energy)
+
+    # Transient density: peak count in rectified-RMS gradient
+    # Coarse envelope over ~20ms windows
+    env_win = max(256, int(samplerate * 0.02))
+    envelope = np.array([
+        float(np.sqrt(np.mean(data[i:i + env_win] ** 2)))
+        for i in range(0, len(data), env_win)
+    ])
+    if envelope.size > 1:
+        diffs = np.diff(envelope)
+        # Count upward transitions above a dynamic threshold
+        thresh = max(envelope.std() * 1.5, 1e-4)
+        peaks = int(np.sum(diffs > thresh))
+        transient_density = float(peaks / max(duration, 0.001))
+    else:
+        transient_density = 0.0
+
+    # Clear downbeat: peaks evenly spaced
+    has_clear_downbeat = False
+    if envelope.size > 4:
+        # Find top-N peaks and check interval stddev
+        peak_positions = np.argsort(envelope)[-8:]
+        peak_positions.sort()
+        if len(peak_positions) >= 3:
+            intervals = np.diff(peak_positions)
+            if intervals.size > 0 and float(np.mean(intervals)) > 0:
+                cv = float(np.std(intervals)) / float(np.mean(intervals))
+                has_clear_downbeat = cv < 0.5  # low variation → steady
+
+    return {
+        "duration_seconds": duration,
+        "frequency_center": frequency_center,
+        "frequency_spread": frequency_spread,
+        "brightness": brightness,
+        "transient_density": transient_density,
+        "has_clear_downbeat": has_clear_downbeat,
+    }

package/mcp_server/sample_engine/critics.py

@@ -164,21 +164,36 @@ def run_frequency_fit_critic(
 ) -> CriticResult:
     """Score frequency fit against existing mix.
 
-    Without mix_snapshot (no M4L bridge), returns neutral 0.5.
+    BUG-B38 fix: the old stub branch returned a neutral 0.5 "fair"
+    score even when the analyzer had no spectral data at all —
+    misleading the user into thinking the sample was a middling fit
+    when in reality the critic couldn't evaluate anything. We now
+    mark the result as explicitly unavailable (score=-1 sentinel +
+    available=False + rating="unavailable") so downstream aggregators
+    can skip this critic rather than fold a fake 0.5 into the overall
+    score.
     """
     if mix_snapshot is None or not mix_snapshot:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
-            recommendation="No spectral data — verify frequency fit by ear",
-            adjustments=[{"note": "stub — spectral overlap analysis not yet implemented"}],
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
+            recommendation=(
+                "No mix snapshot available — load LivePilot_Analyzer on "
+                "master and call get_mix_snapshot first. Falling back to "
+                "by-ear verification."
+            ),
         )
 
     # Basic frequency overlap check using mix_snapshot track data
-    # mix_snapshot expected shape: {"tracks": [{"name": ..., "peak_frequency": ...}]}
     tracks = mix_snapshot.get("tracks", [])
     if not tracks:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
             recommendation="Mix snapshot has no track data",
         )
 
@@ -186,8 +201,14 @@ def run_frequency_fit_critic(
     sample_center = profile.frequency_center
     if sample_center <= 0:
         return CriticResult(
-            critic_name="frequency_fit", score=0.5,
-            recommendation="Sample has no spectral data — verify by ear",
+            critic_name="frequency_fit",
+            score=-1.0,
+            available=False,
+            rating_override="unavailable",
+            recommendation=(
+                "Sample has no spectral data — analyze_sample couldn't "
+                "decode the file, or it's a clip-only reference."
+            ),
         )
 
     # Count tracks with energy near the sample's center frequency

package/mcp_server/sample_engine/models.py

@@ -82,15 +82,32 @@ class SampleIntent:
 
 @dataclass
 class CriticResult:
-    """Result from a single sample critic."""
+    """Result from a single sample critic.
+
+    BUG-B38: added `available` + rating override so critics can
+    explicitly mark themselves as unevaluated (e.g. no mix snapshot
+    for frequency_fit) rather than returning a misleading 0.5 score.
+    Downstream aggregators check `available` before folding a critic's
+    score into the composite.
+    """
 
     critic_name: str
     score: float
     recommendation: str
     adjustments: list = field(default_factory=list)
+    # Explicit availability flag — False when critic couldn't evaluate
+    # (score will be -1.0 sentinel; aggregators should skip)
+    available: bool = True
+    # Optional hand-set rating label — overrides the score-based
+    # default when provided (used for "unavailable" status)
+    rating_override: str = ""
 
     @property
     def rating(self) -> str:
+        if self.rating_override:
+            return self.rating_override
+        if not self.available:
+            return "unavailable"
         if self.score >= 0.8:
             return "excellent"
         if self.score >= 0.6:
@@ -102,6 +119,8 @@ class CriticResult:
     def to_dict(self) -> dict:
         d = asdict(self)
         d["rating"] = self.rating
+        # Strip internal override from payload (not for consumers)
+        d.pop("rating_override", None)
         return d
 
 

package/mcp_server/sample_engine/tools.py

@@ -6,12 +6,15 @@ direct Splice online catalog hunt/download via the gRPC client.
 
 from __future__ import annotations
 
+import logging
 import os
 from typing import Optional
 
 from fastmcp import Context
 
 from ..server import mcp
+
+logger = logging.getLogger(__name__)
 from .models import SampleProfile, SampleIntent, SampleFitReport
 from .analyzer import build_profile_from_filename
 from .critics import run_all_sample_critics
@@ -47,8 +50,8 @@ async def analyze_sample(
                 )
                 if not result.get("error"):
                     file_path = result.get("file_path")
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("m4l get_clip_file_path failed: %s", exc)
 
     if file_path is None:
         return {"error": "Could not determine file path — provide file_path directly"}
@@ -97,34 +100,70 @@ def evaluate_sample_fit(
                 name = track_info.get("name", "").lower()
                 if name:
                     existing_roles.append(name)
-            except Exception:
+            except Exception as exc:
+                logger.debug("get_track_info(%d) skipped: %s", i, exc)
                 continue
 
-        # Detect key from MIDI tracks
+        # Detect key from MIDI tracks.
+        # BUG-B37 fix: the old code checked clip_info.get("is_midi") but
+        # the Remote Script returns is_midi_clip (different field name),
+        # so the check always failed and song_key stayed None —
+        # key_fit then reported "Song key unknown" even on obvious
+        # Dm sessions. Now we check both field names for safety AND
+        # aggregate notes from all harmonic tracks via harmonic_score
+        # (Batch 5 helper), so key detection uses the richest signal.
         try:
             from ..tools._theory_engine import detect_key
-            for i in range(min(track_count, 8)):
+            from ..tools._composition_engine.harmony import harmonic_score
+
+            # Collect all tracks' notes, scored by harmonic-ness
+            harmonic_pool: list[dict] = []
+            for i in range(min(track_count, 16)):
                 try:
                     clip_info = ableton.send_command("get_clip_info", {
                         "track_index": i, "clip_index": 0,
                     })
-                    if clip_info.get("is_midi"):
-                        notes_result = ableton.send_command("get_notes", {
-                            "track_index": i, "clip_index": 0,
-                        })
-                        notes = notes_result.get("notes", [])
-                        if notes:
-                            key_result = detect_key(notes)
-                            mode = key_result.get("mode", "")
-                            mode_suffix = "m" if "minor" in mode else ""
-                            song_key = f"{key_result['tonic_name']}{mode_suffix}"
-                            break
-                except Exception:
+                except Exception as exc:
+                    logger.debug("get_clip_info(%d) skipped: %s", i, exc)
+                    continue
+                # Accept either the new is_midi_clip field or the legacy
+                # is_midi (in case some install combines versions)
+                is_midi = (
+                    clip_info.get("is_midi_clip")
+                    or clip_info.get("is_midi")
+                    or False
+                )
+                if not is_midi:
+                    continue
+                try:
+                    notes_result = ableton.send_command("get_notes", {
+                        "track_index": i, "clip_index": 0,
+                    })
+                except Exception as exc:
+                    logger.debug("get_notes(%d) skipped: %s", i, exc)
+                    continue
+                notes = notes_result.get("notes", []) if isinstance(
+                    notes_result, dict
+                ) else []
+                if not notes:
                     continue
+                track_name = (
+                    existing_roles[i] if i < len(existing_roles) else ""
+                )
+                if harmonic_score(notes, track_name) >= 0.3:
+                    harmonic_pool.extend(notes)
+
+            if harmonic_pool:
+                key_result = detect_key(harmonic_pool)
+                mode = key_result.get("mode", "")
+                mode_suffix = "m" if "minor" in mode else ""
+                song_key = f"{key_result['tonic_name']}{mode_suffix}"
         except ImportError:
             pass
-    except Exception:
-        pass
+        except Exception as exc:
+            logger.debug("key aggregation failed: %s", exc)
+    except Exception as exc:
+        logger.warning("session context for evaluate_sample_fit failed: %s", exc)
 
     critics = run_all_sample_critics(
         profile=profile,
@@ -243,7 +282,8 @@ async def search_samples(
                         },
                     })
                 used_grpc = True
-            except Exception:
+            except Exception as exc:
+                logger.warning("Splice gRPC search failed, falling back to SQL: %s", exc)
                 used_grpc = False
 
         # Also query local index (if not already covered by gRPC) to surface
@@ -282,10 +322,11 @@ async def search_samples(
                         d = candidate.to_dict()
                         d["source_priority"] = 2
                         results.append(d)
-                except Exception:
+                except Exception as exc:
+                    logger.debug("browser search %s skipped: %s", category, exc)
                     continue
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.warning("browser search unavailable: %s", exc)
 
     # Filesystem search
     if source in (None, "filesystem"):
@@ -442,7 +483,8 @@ def get_sample_opportunities(ctx: Context) -> dict:
     try:
         ableton = ctx.lifespan_context["ableton"]
         info = ableton.send_command("get_session_info", {})
-    except Exception:
+    except Exception as exc:
+        logger.warning("get_sample_opportunities: Ableton not reachable: %s", exc)
         return {"opportunities": [], "note": "Cannot read session — Ableton not connected"}
 
     track_count = info.get("track_count", 0)
@@ -458,7 +500,8 @@ def get_sample_opportunities(ctx: Context) -> dict:
             for d in devices:
                 if d.get("class_name") in ("OriginalSimpler", "MultiSampler"):
                     has_sampler = True
-        except Exception:
+        except Exception as exc:
+            logger.debug("track scan idx=%d skipped: %s", i, exc)
             continue
 
     # No organic texture
@@ -542,8 +585,8 @@ def plan_slice_workflow(
         if ableton:
             info = ableton.send_command("get_session_info", {})
             tempo = float(info.get("tempo", 120.0))
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("plan_slice_workflow tempo fetch failed (using 120): %s", exc)
 
     # Read slice count from existing Simpler if track provided
     slice_count = 8  # Default transient slice count
@@ -556,8 +599,8 @@ def plan_slice_workflow(
                 })
                 if isinstance(slices, dict) and slices.get("slice_count"):
                     slice_count = slices["slice_count"]
-        except Exception:
-            pass  # Fall back to default
+        except Exception as exc:
+            logger.debug("get_simpler_slices failed (using default 8): %s", exc)
 
     # Build the plan
     plan = plan_slice_steps(
@@ -891,7 +934,7 @@ async def splice_download_sample(
     try:
         info = await client.get_credits()
         response["credits_remaining"] = int(info.credits)
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.warning("post-download credit check failed: %s", exc)
 
     return response

package/mcp_server/semantic_moves/sound_design_compilers.py

@@ -14,9 +14,11 @@ from . import resolvers
 def _compile_add_warmth(move: SemanticMove, kernel: dict) -> CompiledPlan:
     """Compile 'add_warmth': volume boost + reverb send for perceived warmth.
 
-    SAFETY: Never blindly set device parameters — device_index=0, parameter_index=0
-    can kill audio if the first device isn't a Saturator. Only adjust device params
-    when find_device_on_track confirms a Saturator is present.
+    SAFETY: Never target device parameters by raw index. Ableton's parameter
+    index 0 is "Device On" on every device, so set_device_parameter(idx=0)
+    with any fractional value rounds to 0 and DISABLES the device. Use sends
+    and volume for warmth; device-param automation is only safe once the
+    resolver can look parameters up by name.
     """
     steps = []
     descriptions = []
@@ -31,24 +33,6 @@ def _compile_add_warmth(move: SemanticMove, kernel: dict) -> CompiledPlan:
         idx = t["index"]
         name = t["name"]
 
-        # Try to find a Saturator on the track (safe device adjustment)
-        saturator = resolvers.find_device_on_track(kernel, idx, "Saturator")
-        if saturator:
-            steps.append(CompiledStep(
-                tool="set_device_parameter",
-                params={
-                    "track_index": idx,
-                    "device_index": saturator["device_index"],
-                    "parameter_index": 0,
-                    "value": 0.3,
-                },
-                description=f"Gentle Saturator drive on {name}",
-            ))
-            descriptions.append(f"Saturate {name}")
-        else:
-            # No Saturator found — use volume + send instead of risky device params
-            warnings.append(f"No Saturator on {name} — using volume+reverb for warmth")
-
         # Boost volume slightly for perceived warmth
         steps.append(CompiledStep(
             tool="set_track_volume",
@@ -84,32 +68,22 @@ def _compile_add_warmth(move: SemanticMove, kernel: dict) -> CompiledPlan:
 
 
 def _compile_add_texture(move: SemanticMove, kernel: dict) -> CompiledPlan:
-    """Compile 'add_texture': perlin filter motion + delay send."""
+    """Compile 'add_texture': delay send for spatial texture.
+
+    Device-parameter automation (perlin filter motion) was removed because it
+    targeted device_index=0, parameter_index=0 without a resolver check — that
+    hits "Device On" on every Ableton device and would silently disable the
+    first device. Re-enable once resolvers.find_device_parameter lands.
+    """
     steps = []
     descriptions = []
+    warnings = []
 
     targets = resolvers.find_tracks_by_role(kernel, ["pad", "chords", "lead"])
 
     for t in targets[:1]:
         idx = t["index"]
         name = t["name"]
-        steps.append(CompiledStep(
-            tool="apply_automation_shape",
-            params={
-                "track_index": idx,
-                "clip_index": 0,
-                "parameter_type": "device",
-                "device_index": 0,
-                "parameter_index": 0,
-                "curve_type": "perlin",
-                "center": 0.4,
-                "amplitude": 0.2,
-                "duration": 8,
-                "density": 16,
-            },
-            description=f"Perlin filter motion on {name} for organic texture",
-        ))
-        descriptions.append(f"Perlin filter on {name}")
 
         # Add delay send
         steps.append(CompiledStep(
@@ -119,6 +93,9 @@ def _compile_add_texture(move: SemanticMove, kernel: dict) -> CompiledPlan:
         ))
         descriptions.append(f"Delay texture on {name}")
 
+    if not targets:
+        warnings.append("No pad/chords/lead tracks — texture needs a melodic bed")
+
     steps.append(CompiledStep(
         tool="get_track_meters",
         params={"include_stereo": True},
@@ -132,14 +109,17 @@ def _compile_add_texture(move: SemanticMove, kernel: dict) -> CompiledPlan:
         risk_level="medium",
         summary="; ".join(descriptions) if descriptions else "No tracks for texture",
         requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
     )
 
 
 def _compile_shape_transients(move: SemanticMove, kernel: dict) -> CompiledPlan:
     """Compile 'shape_transients': push drum volume for punch, adjust sends.
 
-    SAFETY: Never blindly set device parameters. Only adjust Compressor params
-    when find_device_on_track confirms one exists. Otherwise use volume for punch.
+    SAFETY: Never target device parameters by raw index. Index 0 on every
+    Ableton device is "Device On" — writing 0.2 rounds to 0 and disables the
+    device. Punch is achieved via volume + send shaping; Compressor attack
+    automation is only safe once the resolver can look parameters up by name.
     """
     steps = []
     descriptions = []
@@ -158,24 +138,7 @@ def _compile_shape_transients(move: SemanticMove, kernel: dict) -> CompiledPlan:
         idx = dt["index"]
         name = dt["name"]
 
-        # Try to find a Compressor on the track
-        compressor = resolvers.find_device_on_track(kernel, idx, "Compressor")
-        if compressor:
-            steps.append(CompiledStep(
-                tool="set_device_parameter",
-                params={
-                    "track_index": idx,
-                    "device_index": compressor["device_index"],
-                    "parameter_index": 0,
-                    "value": 0.2,
-                },
-                description=f"Faster Compressor attack on {name} for snap",
-            ))
-            descriptions.append(f"Shape {name} compressor")
-        else:
-            warnings.append(f"No Compressor on {name} — using volume push for punch")
-
-        # Push volume for transient punch regardless
+        # Push volume for transient punch
         steps.append(CompiledStep(
             tool="set_track_volume",
             params={"track_index": idx, "volume": 0.75},

package/mcp_server/semantic_moves/tools.py

@@ -14,6 +14,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import registry
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 @mcp.tool()
@@ -80,7 +83,8 @@ def preview_semantic_move(
                 info = ableton.send_command("get_session_info")
                 if isinstance(info, dict):
                     session_info = info
-            except Exception:
+            except Exception as exc:
+                logger.debug("preview_semantic_move failed: %s", exc)
                 session_info = {}
 
         state = build_capability_state(

package/mcp_server/semantic_moves/transition_compilers.py

@@ -8,31 +8,20 @@ from . import resolvers
 
 
 def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> CompiledPlan:
-    """Compile 'increase_forward_motion': rising filter + rhythm push."""
+    """Compile 'increase_forward_motion': rhythm push + reverb wash.
+
+    Device-parameter automation (rising filter sweep) was removed: targeting
+    device_index=0, parameter_index=0 without a resolver lookup hits "Device
+    On" on every Ableton device and would disable the first effect. Re-enable
+    once resolvers.find_device_parameter can locate a filter cutoff by name.
+    """
     steps = []
     descriptions = []
+    warnings = []
 
     melodic = resolvers.find_tracks_by_role(kernel, ["chords", "lead", "pad"])
     drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
 
-    for mt in melodic[:1]:
-        steps.append(CompiledStep(
-            tool="apply_automation_shape",
-            params={
-                "track_index": mt["index"],
-                "clip_index": 0,
-                "parameter_type": "device",
-                "device_index": 0,
-                "parameter_index": 0,
-                "curve_type": "exponential",
-                "start": 0.2,
-                "end": 0.7,
-                "duration": 4,
-            },
-            description=f"Rising filter sweep on {mt['name']} over 4 bars",
-        ))
-        descriptions.append(f"Rising filter on {mt['name']}")
-
     for dt in drums[:1]:
         steps.append(CompiledStep(
             tool="set_track_volume",
@@ -49,6 +38,9 @@ def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> Compil
         ))
         descriptions.append(f"Reverb wash on {mt['name']}")
 
+    if not drums and not melodic:
+        warnings.append("No drum or melodic tracks — cannot build forward motion")
+
     steps.append(CompiledStep(
         tool="get_track_meters",
         params={"include_stereo": True},
@@ -62,6 +54,7 @@ def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> Compil
         risk_level="low",
         summary="; ".join(descriptions) if descriptions else "No melodic tracks for motion",
         requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
     )