livepilot 1.10.6 → 1.10.8

package/mcp_server/semantic_moves/mix_moves.py

@@ -92,7 +92,7 @@ REDUCE_REPETITION = SemanticMove(
     ],
     verification_plan=[
         {"tool": "get_track_meters", "check": "all tracks still producing audio", "backend": "remote_command"},
-        {"tool": "capture_audio", "check": "LRA > 2 LU (dynamic range should increase)", "backend": "mcp_tool"},
+        {"tool": "capture_audio", "check": "LRA > 2 LU (dynamic range should increase)", "backend": "bridge_command"},
     ],
 )
 

package/mcp_server/semantic_moves/models.py

@@ -24,6 +24,10 @@ class SemanticMove:
     plan_template: list = field(default_factory=list)  # [{tool, params, description}] — static metadata, NOT runtime truth
     verification_plan: list = field(default_factory=list)  # [{tool, check}]
     confidence: float = 0.7
+    # analytical_only: move is intentionally metadata-only — no compiler is
+    # expected. Surfaces in discovery/wonder_mode but never executes. Set this
+    # to True for moves that are deliberate "hints" rather than orphan-by-bug.
+    analytical_only: bool = False
 
     def to_dict(self) -> dict:
         return {
@@ -36,6 +40,7 @@ class SemanticMove:
             "required_capabilities": self.required_capabilities,
             "plan_template_steps": len(self.plan_template),
             "confidence": self.confidence,
+            "analytical_only": self.analytical_only,
         }
 
     def to_full_dict(self) -> dict:

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

@@ -229,10 +229,21 @@ async def apply_semantic_move(
     # explore mode — execute through the async router
     from ..runtime.execution_router import execute_plan_steps_async
 
-    step_dicts = [
-        {"tool": step.tool, "params": step.params, "description": step.description}
-        for step in plan.steps
-    ]
+    # Propagate the optional backend annotation through to the router so a
+    # compiler that's certain about a step's backend (e.g. bridge_command for
+    # capture_audio) can short-circuit classify_step(). Steps without backend
+    # fall back to the classifier as before.
+    def _step_to_dict(step):
+        d = {
+            "tool": step.tool,
+            "params": step.params,
+            "description": step.description,
+        }
+        if getattr(step, "backend", None):
+            d["backend"] = step.backend
+        return d
+
+    step_dicts = [_step_to_dict(step) for step in plan.steps]
     bridge = ctx.lifespan_context.get("m4l")
     mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
     exec_results = await execute_plan_steps_async(

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,
     )
 
 

package/mcp_server/server.py

@@ -2,6 +2,7 @@
 
 from contextlib import asynccontextmanager
 import asyncio
+import logging
 import os
 import subprocess
 
@@ -10,6 +11,12 @@ from fastmcp import FastMCP, Context  # noqa: F401
 from .connection import AbletonConnection
 from .m4l_bridge import SpectralCache, SpectralReceiver, M4LBridge
 
+# Logger must be defined before any function uses it — several module-level
+# helpers below (e.g. _master_has_livepilot_analyzer) call logger.debug on
+# the import-time code path, so defining logger later raised NameError when
+# those helpers fired from a tool module's module-level init.
+logger = logging.getLogger(__name__)
+
 
 def _identify_port_holder(port: int) -> str | None:
     """Identify which process holds the given UDP port (for logging only).
@@ -33,13 +40,76 @@ def _identify_port_holder(port: int) -> str | None:
                         text=True, timeout=2,
                     ).strip()
                     return f"{pid} ({cmdline[:60]})"
-                except (subprocess.CalledProcessError, FileNotFoundError):
+                except (subprocess.CalledProcessError,
+                        subprocess.TimeoutExpired,
+                        FileNotFoundError):
                     return str(pid)
         return None
-    except (subprocess.CalledProcessError, FileNotFoundError, ValueError):
+    except (subprocess.CalledProcessError,
+            subprocess.TimeoutExpired,
+            FileNotFoundError,
+            ValueError):
+        # TimeoutExpired catches the busy-system case where lsof exceeds
+        # the 3-second budget; we treat it as "can't identify" and return
+        # None so startup never stalls for slow host diagnostics.
         return None
 
 
+def _check_remote_script_version(ableton: AbletonConnection) -> None:
+    """BUG-A1: detect stale Remote Script installs at startup.
+
+    The installed Remote Script is loaded by Ableton at its own launch time
+    and cached in Python's module system — source-tree edits don't take
+    effect until the user reinstalls + restarts Live. When the installed
+    copy lags behind the MCP-server source, commands added after the install
+    date (e.g. ``insert_device`` in v1.10.6) return "Unknown command type".
+
+    This check pings the Remote Script, compares its reported version to
+    the MCP server version, and logs a loud warning on mismatch. We don't
+    abort — the server should still work for whatever handlers the older
+    Remote Script does support — but we make the drift visible.
+    """
+    import sys
+
+    try:
+        from . import __version__ as mcp_version
+    except ImportError:
+        mcp_version = "unknown"
+
+    try:
+        pong = ableton.send_command("ping")
+    except Exception as exc:
+        import logging as _logging
+        _logging.getLogger(__name__).debug(
+            "Remote Script version check failed: %s", exc,
+        )
+        return
+
+    if not isinstance(pong, dict):
+        return
+    rs_version = pong.get("remote_script_version")
+    if rs_version is None:
+        # Remote Script is old enough that it doesn't even embed its version
+        # in ping responses — definitely stale.
+        msg = (
+            "LivePilot: Remote Script is out of date (pre-version-handshake). "
+            "Run 'npx livepilot --install' and restart Ableton Live to fix "
+            "'Unknown command type' errors for newer tools (insert_device, "
+            "set_clip_pitch, etc)."
+        )
+        print(msg, file=sys.stderr)
+        return
+
+    if str(rs_version) != str(mcp_version):
+        msg = (
+            f"LivePilot: Remote Script version {rs_version} does not match "
+            f"MCP server version {mcp_version}. Newer tools may fail with "
+            f"'Unknown command type'. Run 'npx livepilot --install' and "
+            f"restart Ableton Live to resync."
+        )
+        print(msg, file=sys.stderr)
+
+
 def _master_has_livepilot_analyzer(ableton: AbletonConnection) -> bool:
     """Check whether the analyzer device is currently on the master track."""
     try:
@@ -128,6 +198,9 @@ async def lifespan(server):
     }
 
     try:
+        # BUG-A1: detect stale Remote Script installs early so the user
+        # sees a clear message instead of cryptic "Unknown command type" errors.
+        _check_remote_script_version(ableton)
         if bridge_state["transport"] is not None:
             await _warm_analyzer_bridge(ableton, spectral)
         yield {
@@ -198,9 +271,6 @@ from .device_forge import tools as device_forge_tools          # noqa: F401, E40
 from .sample_engine import tools as sample_engine_tools        # noqa: F401, E402
 from .atlas import tools as atlas_tools                        # noqa: F401, E402
 from .composer import tools as composer_tools                  # noqa: F401, E402
-import logging
-
-logger = logging.getLogger(__name__)
 
 # ---------------------------------------------------------------------------
 # Schema coercion patch — accept strings for numeric parameters

package/mcp_server/services/singletons.py

@@ -0,0 +1,68 @@
+"""Thread-safe singleton helpers.
+
+The server has several subsystems (atlas, corpus, sample-engine indexes)
+that are loaded lazily into module-level globals via a check-then-set
+pattern. Under FastMCP's async concurrency that pattern races: two
+handlers can both observe ``None`` and both construct the (expensive)
+object. Most of the time the GIL hides the race, but when it doesn't you
+get redundant I/O and, worse, one thread's half-parsed state overwriting
+the other's completed state.
+
+This module provides a small helper that wraps a factory in a lock and
+optionally tracks an on-disk mtime for cache invalidation. Use it in
+place of hand-rolled ``_instance = None`` patterns.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from threading import Lock
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+class Singleton:
+    """Lazy, thread-safe singleton with optional mtime-based reload.
+
+    Example:
+        atlas_holder = Singleton(_load_atlas)
+
+        def get_atlas():
+            return atlas_holder.get(reload_if_newer=atlas_path)
+
+        def on_atlas_rebuild():
+            atlas_holder.invalidate()
+    """
+
+    def __init__(self, factory: Callable[[], T]):
+        self._factory = factory
+        self._instance: T | None = None
+        self._mtime: float | None = None
+        self._lock = Lock()
+
+    def get(self, *, reload_if_newer: Path | None = None) -> T:
+        with self._lock:
+            if self._instance is None:
+                self._instance = self._factory()
+                if reload_if_newer is not None:
+                    try:
+                        self._mtime = reload_if_newer.stat().st_mtime
+                    except OSError:
+                        self._mtime = None
+                return self._instance
+
+            if reload_if_newer is not None:
+                try:
+                    current = reload_if_newer.stat().st_mtime
+                except OSError:
+                    return self._instance
+                if self._mtime is None or current > self._mtime:
+                    self._instance = self._factory()
+                    self._mtime = current
+            return self._instance
+
+    def invalidate(self) -> None:
+        """Discard the cached instance. Next .get() will re-run the factory."""
+        with self._lock:
+            self._instance = None
+            self._mtime = None

package/mcp_server/session_continuity/models.py

@@ -50,6 +50,9 @@ class SessionStory:
     """The narrative of the current session."""
 
     song_id: str = ""
+    # BUG-B16: link back to the SongBrain snapshot that generated the
+    # identity_summary so callers can tell which brain was used.
+    song_brain_id: str = ""
     identity_summary: str = ""
     what_changed_last: str = ""
     what_still_feels_open: list[str] = field(default_factory=list)
@@ -60,6 +63,7 @@ class SessionStory:
     def to_dict(self) -> dict:
         return {
             "song_id": self.song_id,
+            "song_brain_id": self.song_brain_id,
             "identity_summary": self.identity_summary,
             "what_changed_last": self.what_changed_last,
             "what_still_feels_open": self.what_still_feels_open,

package/mcp_server/session_continuity/tracker.py

@@ -50,10 +50,23 @@ def reset_story() -> None:
 def get_session_story(
     song_brain: Optional[dict] = None,
 ) -> SessionStory:
-    """Get the current session story with identity summary."""
+    """Get the current session story with identity summary.
+
+    BUG-B16: now also populates song_brain_id from the passed brain so
+    callers can tell which brain generated the identity_summary.
+    Previously the field was empty and users got a half-populated
+    response that read as "something's wrong" even though the partial
+    data was correct for a fresh session.
+    """
     song_brain = song_brain or {}
 
     _story.identity_summary = song_brain.get("identity_core", "")
+    _story.song_brain_id = str(song_brain.get("brain_id", "") or "")
+    # Carry song_id through when present on the brain — fresh sessions
+    # leave this empty, which is documented below.
+    if not _story.song_id and song_brain.get("song_id"):
+        _story.song_id = str(song_brain.get("song_id"))
+
     _story.threads = [t for t in _threads.values() if t.status == "open"]
     _story.turns = _turns
     _story.what_still_feels_open = [

package/mcp_server/song_brain/builder.py

@@ -127,6 +127,14 @@ def _infer_identity_core(
     """Infer the single strongest defining idea in the session.
 
     Returns (description, confidence).
+
+    BUG-B10 fix: the old logic picked "Dominant texture: drums" at
+    confidence 0.5 for almost every session — because drum tracks
+    typically have the most notes. We now consider richer signals:
+    featured vocals, scene-name aesthetics, tempo+key context, and
+    single-instrument dominance. When multiple low-confidence signals
+    align (e.g. "dust" aesthetic + vocal hook + D minor key), we
+    combine them into a compound identity string.
     """
     candidates: list[tuple[str, float]] = []
 
@@ -144,7 +152,7 @@ def _infer_identity_core(
     if arc_type:
         candidates.append((f"Emotional arc: {arc_type}", 0.6))
 
-    # From role graph — dominant texture
+    # From role graph — dominant texture (kept but gently deranked)
     # role_graph format: {track_name: {index: int, role: str}}
     if role_graph:
         role_counts = Counter(
@@ -153,9 +161,15 @@ def _infer_identity_core(
             if isinstance(info, dict)
         )
         role_counts.pop("unknown", None)
-        if role_counts:
-            dominant_role = role_counts.most_common(1)[0]
-            candidates.append((f"Dominant texture: {dominant_role[0]}", 0.5))
+        # B10 fix: drums being the "dominant texture" is almost never
+        # what the song is ABOUT — it's just that drum tracks have the
+        # most notes. Skip drums/perc from this candidate stream.
+        _BORING_DOMINANT = {"drums", "percussion", "kick", "snare", "hat"}
+        for role, _ in role_counts.most_common(3):
+            if role.lower() in _BORING_DOMINANT:
+                continue
+            candidates.append((f"Dominant texture: {role}", 0.55))
+            break
 
     # From track analysis — genre/style cues
     track_names = [t.get("name", "").lower() for t in tracks]
@@ -163,12 +177,65 @@ def _infer_identity_core(
     if genre_cues:
         candidates.append((f"Style: {genre_cues}", 0.4))
 
+    # BUG-B10: featured instrument — a named vocal/pad/lead track with
+    # an explicit function is usually more identity-defining than
+    # "dominant texture: drums".
+    _FEATURED_TOKENS = (
+        ("vocal", "vocal hook", 0.75),
+        ("vox", "vocal hook", 0.72),
+        ("pad", "pad-led atmosphere", 0.55),
+        ("lead", "lead synth melody", 0.65),
+        ("rhodes", "rhodes-keys texture", 0.60),
+        ("piano", "piano-led harmony", 0.60),
+        ("guitar", "guitar-led", 0.60),
+        ("saxophone", "saxophone solo", 0.65),
+        ("brass", "brass section", 0.55),
+    )
+    for name in track_names:
+        for token, label, conf in _FEATURED_TOKENS:
+            if token in name:
+                candidates.append((f"Featured element: {label}", conf))
+                break
+
+    # BUG-B10: scene-name aesthetic cues. A scene named "Intro Dust" /
+    # "Outro Dust" signals a deliberate dust/lo-fi aesthetic; "Sun Peak"
+    # / "Peak" signals a climax-oriented structure. Pull these from the
+    # composition-analysis section list if present.
+    _AESTHETIC_TOKENS = (
+        ("dust", "dust-toned lo-fi"),
+        ("sun", "warm/sun-peaked"),
+        ("fog", "foggy/dreamy"),
+        ("glass", "brittle/glass-like"),
+        ("void", "void/ambient-spatial"),
+        ("haze", "hazy/nostalgic"),
+        ("bloom", "blooming/evolving"),
+    )
+    sections = composition.get("sections", []) or []
+    section_names = " ".join(
+        str(s.get("name", "") or s.get("label", "")).lower()
+        for s in sections
+    )
+    for token, label in _AESTHETIC_TOKENS:
+        if token in section_names:
+            candidates.append((f"Aesthetic: {label}", 0.55))
+            break
+
     if not candidates:
         # Fallback: describe by track count and tempo
         return ("Emerging piece — identity not yet established", 0.2)
 
-    best = max(candidates, key=lambda c: c[1])
-    return best
+    # BUG-B10: when no single candidate is confident (>0.6), blend the
+    # top 2 into a compound identity — captures "vocal hook + dust
+    # aesthetic" style identity rather than picking one weak signal.
+    candidates.sort(key=lambda c: c[1], reverse=True)
+    top = candidates[0]
+    if top[1] >= 0.6 or len(candidates) < 2:
+        return top
+    # Blend top 2
+    second = candidates[1]
+    blended_desc = f"{top[0]} + {second[0].lower()}"
+    blended_conf = min(0.85, (top[1] + second[1]) / 2 + 0.1)
+    return (blended_desc, blended_conf)
 
 
 def _detect_genre_cues(track_names: list[str]) -> str:
@@ -260,6 +327,12 @@ def _detect_sacred_elements(
 # ── Section purposes ──────────────────────────────────────────────
 
 
+# Section intents that imply this is a "payoff" / arrival moment.
+# Used by _infer_section_purposes to derive is_payoff consistently
+# when composition returns an intent label without the explicit flag.
+_PAYOFF_INTENTS = frozenset({"payoff", "drop", "chorus", "hook"})
+
+
 def _infer_section_purposes(
     scenes: list[dict],
     composition: dict,
@@ -271,12 +344,27 @@ def _infer_section_purposes(
     comp_sections = composition.get("sections", [])
     if comp_sections:
         for sec in comp_sections:
+            name = str(sec.get("name", ""))
+            # BUG-B12: skip empty placeholder sections that pollute the
+            # energy_arc and section_purposes list. A section with no name
+            # AND zero energy corresponds to an unnamed empty scene slot.
+            if not name.strip() and not sec.get("energy", 0):
+                continue
+            intent = sec.get("intent", sec.get("purpose", "")) or ""
+            # BUG-B11: derive is_payoff from the intent label when the
+            # explicit flag isn't set. Composition engine returns
+            # intent="drop"/"chorus"/"hook"/"payoff" — these all mean the
+            # section IS a payoff, so is_payoff must reflect that.
+            is_payoff = bool(
+                sec.get("is_payoff", False)
+                or intent.lower() in _PAYOFF_INTENTS
+            )
             sections.append(SectionPurpose(
-                section_id=sec.get("id", sec.get("name", "")),
-                label=sec.get("label", sec.get("name", "")),
-                emotional_intent=sec.get("intent", sec.get("purpose", "")),
+                section_id=sec.get("id", name),
+                label=sec.get("label", name),
+                emotional_intent=intent,
                 energy_level=sec.get("energy", 0.5),
-                is_payoff=sec.get("is_payoff", False),
+                is_payoff=is_payoff,
                 confidence=0.7,
             ))
         return sections
@@ -284,6 +372,10 @@ def _infer_section_purposes(
     # Fallback: infer from scene names
     for i, scene in enumerate(scenes):
         name = scene.get("name", f"Scene {i}")
+        # BUG-B12 (fallback path): skip empty scenes so they don't pollute
+        # the output even when no composition data is available.
+        if not str(name).strip():
+            continue
         label, intent, energy, is_payoff = _classify_scene_name(name, i, len(scenes))
         sections.append(SectionPurpose(
             section_id=f"scene_{i}",
@@ -389,8 +481,14 @@ def _detect_open_questions(
         ))
 
     # Missing sections (common gaps)
-    labels = {s.label for s in sections}
-    if len(sections) > 3 and "intro" not in labels:
+    # BUG-B14: check substrings across labels AND emotional intents
+    # (case-insensitive) so scene names like "Intro Dust" or intent "intro"
+    # both satisfy the check. Exact-match on the label set missed those.
+    signal_text = " ".join(
+        f"{s.label} {s.emotional_intent}".lower() for s in sections
+    )
+    has_intro = any(kw in signal_text for kw in ("intro", "opening", "opener"))
+    if len(sections) > 3 and not has_intro:
         questions.append(OpenQuestion(
             question="No intro section — does the track need an opening?",
             domain="arrangement",