livepilot 1.10.5 → 1.10.7

package/mcp_server/server.py

@@ -33,20 +33,83 @@ 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:
         track = ableton.send_command("get_master_track")
-    except Exception:
+    except Exception as exc:
+        logger.debug("_master_has_livepilot_analyzer failed: %s", exc)
         return False
-
     devices = track.get("devices", []) if isinstance(track, dict) else []
     for device in devices:
         normalized = " ".join(
@@ -92,7 +155,8 @@ async def lifespan(server):
     splice_client = SpliceGRPCClient()
     try:
         await splice_client.connect()
-    except Exception:
+    except Exception as exc:
+        logger.debug("lifespan failed: %s", exc)
         pass  # client remains in disconnected state
 
     # Start UDP listener for incoming M4L spectral data (port 9880)
@@ -127,6 +191,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 {
@@ -144,10 +211,8 @@ async def lifespan(server):
         ableton.disconnect()
         try:
             await splice_client.disconnect()
-        except Exception:
-            pass
-
-
+        except Exception as exc:
+            logger.debug("lifespan failed: %s", exc)
 mcp = FastMCP("LivePilot", lifespan=lifespan)
 
 # Import tool modules so they register with `mcp`
@@ -199,7 +264,9 @@ 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
@@ -213,6 +280,7 @@ from .composer import tools as composer_tools                  # noqa: F401, E40
 # "5" → 5 and "0.75" → 0.75 automatically, so no tool code changes needed.
 # ---------------------------------------------------------------------------
 
+
 def _coerce_schema_property(prop: dict) -> None:
     """Widen a single JSON Schema property to also accept strings."""
     if prop.get("type") in ("integer", "number") and "anyOf" not in prop:
@@ -253,6 +321,7 @@ def _get_all_tools():
     if hasattr(mcp, "_local_provider") and hasattr(mcp._local_provider, "_components"):
         return list(mcp._local_provider._components.values())
     import sys
+
     print(
         "LivePilot: WARNING — could not access FastMCP tool registry, "
         "string-to-number schema coercion will not work",
@@ -273,7 +342,6 @@ def _patch_tool_schemas() -> None:
             if isinstance(definition, dict):
                 _coerce_schema_property(definition)
 
-
 _patch_tool_schemas()
 
 
@@ -281,6 +349,5 @@ def main():
     """Run the MCP server over stdio."""
     mcp.run(transport="stdio")
 
-
 if __name__ == "__main__":
     main()

package/mcp_server/services/motif_service.py

@@ -9,6 +9,9 @@ Pure computation — no I/O. Callers provide pre-fetched data.
 from __future__ import annotations
 
 from typing import Optional
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def get_motif_data(
@@ -28,13 +31,15 @@ def get_motif_data(
 
     try:
         from ..tools import _motif_engine as motif_engine
+
         motifs = motif_engine.detect_motifs(notes_by_track)
         return {
             "motifs": [m.to_dict() for m in motifs],
             "motif_count": len(motifs),
             "tracks_analyzed": len(notes_by_track),
         }
-    except Exception:
+    except Exception as exc:
+        logger.debug("get_motif_data failed: %s", exc)
         return {"motifs": [], "motif_count": 0, "tracks_analyzed": 0}
 
 
@@ -60,8 +65,9 @@ def fetch_notes_from_ableton(ableton, tracks: list[dict], max_clips: int = 8) ->
                     "clip_index": clip_idx,
                 })
                 track_notes.extend(result.get("notes", []))
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("fetch_notes_from_ableton failed: %s", exc)
+
         if track_notes:
             notes_by_track[t_idx] = track_notes
     return notes_by_track

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/tools.py

@@ -15,6 +15,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import tracker
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 @mcp.tool()
@@ -200,7 +203,6 @@ def explain_preference_vs_identity(
         "note": "Identity has stronger weight inside a session (0.65 vs 0.35)",
     }
 
-
 # ── Helpers ───────────────────────────────────────────────────────
 
 
@@ -222,9 +224,11 @@ def _get_taste_graph(ctx: Context) -> dict:
         from ..memory.taste_graph import build_taste_graph
         from ..memory.taste_memory import TasteMemoryStore
         from ..memory.anti_memory import AntiMemoryStore
+
         taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
         anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
         return build_taste_graph(taste_store=taste_store, anti_store=anti_store).to_dict()
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_get_taste_graph failed: %s", exc)
+
     return {}

package/mcp_server/session_continuity/tracker.py

@@ -7,6 +7,7 @@ Separates taste (cross-session) from identity (in-song) ranking.
 from __future__ import annotations
 
 import hashlib
+import logging
 import time
 from typing import Optional
 
@@ -17,6 +18,8 @@ from .models import (
     TurnResolution,
 )
 
+logger = logging.getLogger(__name__)
+
 
 # ── In-memory state ───────────────────────────────────────────────
 
@@ -47,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 = [
@@ -129,9 +145,8 @@ def record_turn_resolution(
     if _project_store is not None:
         try:
             _project_store.save_turn(turn.to_dict())
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("record_turn_resolution failed: %s", exc)
     return turn
 
 
@@ -158,9 +173,8 @@ def open_thread(description: str, domain: str = "", priority: float = 0.5) -> Cr
     if _project_store is not None:
         try:
             _project_store.save_thread(thread.to_dict())
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("open_thread failed: %s", exc)
     return thread
 
 
@@ -173,8 +187,8 @@ def resolve_thread(thread_id: str) -> Optional[CreativeThread]:
         if _project_store is not None:
             try:
                 _project_store.save_thread(thread.to_dict())
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("resolve_thread failed: %s", exc)
     return thread
 
 

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