livepilot 1.27.1 → 1.27.3

package/mcp_server/mix_engine/tools.py

@@ -84,11 +84,17 @@ def _fetch_mix_data(ctx: Context) -> dict:
 
 
 @mcp.tool()
-def analyze_mix(ctx: Context) -> dict:
+def analyze_mix(ctx: Context, target_style: str = "dynamic") -> dict:
     """Build full mix state and run all critics.
 
     Returns the complete mix analysis including all sub-states
     (balance, masking, dynamics, stereo, depth) and all detected issues.
+
+    target_style: intended dynamics target for the dynamics critic.
+        "dynamic" (default) — standard mix expectations.
+        "loud_master" — deliberately loud, heavily-limited master: the
+        over_compressed check is suppressed (3-6dB crest is the intended
+        sound there, not a defect).
     """
     data = _fetch_mix_data(ctx)
     mix_state = build_mix_state(
@@ -97,7 +103,9 @@ def analyze_mix(ctx: Context) -> dict:
         spectrum=data["spectrum"],
         rms_data=data["rms_data"],
     )
-    issues = run_all_mix_critics(mix_state)
+    issues = run_all_mix_critics(
+        mix_state, dynamics_context={"target_style": target_style}
+    )
     moves = plan_mix_moves(issues, mix_state)
     sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
     sonic_character = extract_character_profile(sonic_snapshot or {})
@@ -113,10 +121,12 @@ def analyze_mix(ctx: Context) -> dict:
 
 
 @mcp.tool()
-def get_mix_issues(ctx: Context) -> dict:
+def get_mix_issues(ctx: Context, target_style: str = "dynamic") -> dict:
     """Run all mix critics and return detected issues only.
 
     Lighter than analyze_mix — skips move planning.
+
+    target_style: "dynamic" (default) or "loud_master" — see analyze_mix.
     """
     data = _fetch_mix_data(ctx)
     mix_state = build_mix_state(
@@ -125,7 +135,9 @@ def get_mix_issues(ctx: Context) -> dict:
         spectrum=data["spectrum"],
         rms_data=data["rms_data"],
     )
-    issues = run_all_mix_critics(mix_state)
+    issues = run_all_mix_critics(
+        mix_state, dynamics_context={"target_style": target_style}
+    )
     sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
 
     return {

package/mcp_server/performance_engine/tools.py

@@ -40,6 +40,39 @@ _POSITIONAL_FALLBACK_ROLES = {
     "default": "verse",
 }
 
+# _composition_engine's SectionType vocabulary is RICHER than the performance
+# VALID_ROLES set (it adds loop / pre_chorus / bridge / unknown / transition_fx).
+# Feeding one of those straight into SceneRole(role=...) trips its __post_init__
+# guard and raises ValueError, which crashes get_performance_state /
+# get_performance_safe_moves / plan_scene_handoff the moment ANY scene resolves
+# to an out-of-vocabulary type (e.g. a scene named "Drums"/"My Idea" → unknown).
+# Map every composition type into the performance vocabulary by musical role.
+_SECTION_TYPE_TO_PERF_ROLE = {
+    "intro": "intro",
+    "verse": "verse",
+    "chorus": "chorus",
+    "build": "build",
+    "drop": "drop",
+    "breakdown": "breakdown",
+    "outro": "outro",
+    "transition": "transition",
+    "transition_fx": "transition",
+    "pre_chorus": "build",     # a pre-chorus builds toward the chorus
+    "bridge": "breakdown",     # a bridge is a contrasting, lower-energy section
+    "loop": "verse",           # a bare loop / idea reads as a steady verse
+    "unknown": "verse",        # neutral default
+}
+
+
+def _to_performance_role(value: str) -> str:
+    """Coerce any composition SectionType value into the performance vocabulary.
+
+    Falls back to 'verse' for any value not in the map so a future SectionType
+    can never crash the performance tools.
+    """
+    role = _SECTION_TYPE_TO_PERF_ROLE.get(value)
+    return role if role is not None else "verse"
+
 
 def _positional_fallback_role(index: int, scene_count: int) -> str:
     """Map a scene index to a role when no composition data is available.
@@ -148,21 +181,36 @@ def _fetch_scene_data(ctx: Context) -> tuple[list[SceneRole], int]:
         name = scene_data.get("name", f"Scene {i}")
         ce_sec = ce_by_scene_idx.get(i)
         if ce_sec is not None:
-            # SectionType is an enum; .value gives the string vocabulary
+            # SectionType is an enum; .value gives the string vocabulary, which
+            # we then coerce into the (narrower) performance VALID_ROLES set.
             stype = ce_sec.section_type
-            role = stype.value if hasattr(stype, "value") else str(stype)
+            raw = stype.value if hasattr(stype, "value") else str(stype)
+            role = _to_performance_role(raw)
             energy = float(ce_sec.energy)
         else:
             # Unnamed scene or build failed — positional fallback
             role = _positional_fallback_role(i, scene_count)
             energy = _positional_fallback_energy(role)
 
-        scene_roles.append(SceneRole(
-            scene_index=i,
-            name=name,
-            energy_level=energy,
-            role=role,
-        ))
+        # Clamp energy and defensively construct: SceneRole.__post_init__ raises
+        # on an out-of-range energy or an unmapped role, and a single raise here
+        # would take down the whole tool. A bad value degrades to a safe scene.
+        energy = max(0.0, min(1.0, energy))
+        try:
+            scene_roles.append(SceneRole(
+                scene_index=i,
+                name=name,
+                energy_level=energy,
+                role=role,
+            ))
+        except ValueError as exc:
+            logger.debug("_fetch_scene_data SceneRole(%r) invalid: %s", role, exc)
+            scene_roles.append(SceneRole(
+                scene_index=i,
+                name=name,
+                energy_level=energy,
+                role="verse",
+            ))
 
     # Determine current scene — default to 0 since session_info
     # doesn't expose a selected_scene field

package/mcp_server/persistence/base_store.py

@@ -70,6 +70,17 @@ class PersistentJsonStore:
         try:
             return json.loads(self._path.read_text(encoding="utf-8"))
         except (json.JSONDecodeError, OSError):
+            # Mirror the read() corruption-recovery path: preserve the
+            # corrupt file as <name>.corrupt so it can be inspected/recovered
+            # rather than being silently overwritten by the next _write_unlocked
+            # call (which update() always performs after _read_unlocked).
+            # Best-effort — a backup failure must not prevent the store from
+            # recovering with defaults.
+            corrupt = self._path.with_suffix(self._path.suffix + ".corrupt")
+            try:
+                self._path.rename(corrupt)
+            except OSError:
+                pass
             return {}
 
     def _write_unlocked(self, data: dict) -> None:

package/mcp_server/persistence/project_store.py

@@ -7,16 +7,35 @@ Located at ~/.livepilot/projects/<hash>/state.json.
 from __future__ import annotations
 
 import hashlib
+import logging
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Optional
 
 from .base_store import PersistentJsonStore
 
+logger = logging.getLogger(__name__)
+
 
 _PROJECTS_DIR = Path.home() / ".livepilot" / "projects"
 _MAX_TURNS = 50
 _MAX_WONDER_OUTCOMES = 10
+# Creative threads accumulate one entry per open_thread() call, and
+# session_continuity mints a fresh thread_id (ms-timestamp-seeded hash) every
+# time — unlike turns/wonder_outcomes there was previously NO cap here, so
+# the list grew monotonically forever and every save_thread() became a
+# full read-modify-write over an ever-larger threads array.
+_MAX_THREADS = 100
+
+# Schema version of the on-disk shape this build writes/expects.
+CURRENT_VERSION = 1
+
+# Migration table: source version -> callable that upgrades data from that
+# version to the next. Empty today — CURRENT_VERSION has been 1 since this
+# store existed. Scaffolding for the day a schema bump actually needs a real
+# migration; until then any version mismatch backs up the raw file and warns
+# instead of silently discarding the project's threads/turns/wonder history.
+_MIGRATIONS: dict[int, Callable[[dict], dict]] = {}
 
 
 def project_hash(session_info: dict) -> str:
@@ -86,6 +105,41 @@ def project_hash(session_info: dict) -> str:
     return hashlib.sha256(seed.encode()).hexdigest()[:12]
 
 
+def _prune_threads(threads: list[dict], max_threads: int) -> list[dict]:
+    """Cap the thread list, preferring to drop resolved threads first.
+
+    Mirrors the capping pattern already used by save_turn (_MAX_TURNS) and
+    save_wonder_outcome (_MAX_WONDER_OUTCOMES) — but threads never had one,
+    and open_thread() mints a fresh thread_id every call, so the list grew
+    monotonically forever.
+
+    Eviction order:
+      1. Resolved threads, oldest-touched first — a long resolved history
+         shouldn't crowd out genuinely open creative threads.
+      2. If resolved threads alone aren't enough to reach the cap, fall back
+         to dropping the oldest-touched threads overall (any status), so the
+         most-recently-touched threads always survive.
+    """
+    if len(threads) <= max_threads:
+        return threads
+
+    overflow = len(threads) - max_threads
+
+    resolved_idx = sorted(
+        (i for i, t in enumerate(threads) if t.get("status") == "resolved"),
+        key=lambda i: threads[i].get("last_touched_ms", 0),
+    )
+    drop: set[int] = set(resolved_idx[:overflow])
+
+    if len(drop) < overflow:
+        remaining_idx = [i for i in range(len(threads)) if i not in drop]
+        remaining_idx.sort(key=lambda i: threads[i].get("last_touched_ms", 0))
+        need_more = overflow - len(drop)
+        drop.update(remaining_idx[:need_more])
+
+    return [t for i, t in enumerate(threads) if i not in drop]
+
+
 class ProjectStore:
     """Persistent per-project state."""
 
@@ -98,28 +152,98 @@ class ProjectStore:
     def project_id(self) -> str:
         return self._project_id
 
+    def _coerce(self, data: dict) -> dict:
+        """Return schema-current data — migrating forward or resetting.
+
+        - version == CURRENT_VERSION: pass through unchanged (hot path).
+        - version has a registered migration chain to CURRENT_VERSION: run it.
+        - anything else (missing/non-int version, or a version this build
+          doesn't know how to migrate — e.g. it's newer than this build):
+          back up the raw file to ``<path>.pre-migration``, log a WARNING,
+          and fall back to defaults. Never silently discard.
+        """
+        version = data.get("version")
+        if version == CURRENT_VERSION:
+            return data
+        migrated = self._migrate(data, version)
+        if migrated is not None:
+            return migrated
+        if data:
+            self._backup_unmigrated(version)
+        return self._default()
+
+    @staticmethod
+    def _migrate(data: dict, version) -> Optional[dict]:
+        """Run the migration chain from ``version`` to CURRENT_VERSION.
+
+        Returns None if there's no registered path (unknown/future version),
+        signalling the caller to fall back to defaults.
+        """
+        if not isinstance(version, int):
+            return None
+        migrated = dict(data)
+        seen: set[int] = set()
+        while migrated.get("version") != CURRENT_VERSION:
+            v = migrated.get("version")
+            if not isinstance(v, int) or v in seen or v not in _MIGRATIONS:
+                return None
+            seen.add(v)
+            migrated = _MIGRATIONS[v](migrated)
+        return migrated
+
+    def _backup_unmigrated(self, version) -> None:
+        """Preserve the raw on-disk file before falling back to defaults."""
+        path = self._store.path
+        backup = path.with_suffix(path.suffix + ".pre-migration")
+        try:
+            if path.exists():
+                path.replace(backup)
+                logger.warning(
+                    "ProjectStore(%s): unrecognized schema version %r in %s "
+                    "(expected %r) — backed up to %s and falling back to "
+                    "defaults; the original data was NOT discarded",
+                    self._project_id, version, path, CURRENT_VERSION, backup,
+                )
+            else:
+                logger.warning(
+                    "ProjectStore(%s): unrecognized schema version %r "
+                    "(expected %r, no on-disk file to back up) — falling "
+                    "back to defaults",
+                    self._project_id, version, CURRENT_VERSION,
+                )
+        except OSError as exc:
+            logger.warning(
+                "ProjectStore(%s): failed to back up unrecognized-version "
+                "file %s (%s) — falling back to defaults without a backup",
+                self._project_id, path, exc,
+            )
+
     def get_all(self) -> dict:
         data = self._store.read()
-        return data if data.get("version") == 1 else self._default()
+        return self._coerce(data)
 
     def save_thread(self, thread: dict) -> None:
-        """Save or update a creative thread."""
+        """Save or update a creative thread (capped at _MAX_THREADS)."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             threads = data.setdefault("threads", [])
             # Update existing or append
             for i, t in enumerate(threads):
                 if t.get("thread_id") == thread.get("thread_id"):
                     threads[i] = thread
-                    return data
-            threads.append(thread)
+                    break
+            else:
+                threads.append(thread)
+            if len(threads) > _MAX_THREADS:
+                threads = _prune_threads(threads, _MAX_THREADS)
+            data["threads"] = threads
             return data
         self._store.update(_update)
 
     def save_turn(self, turn: dict) -> None:
         """Save a turn resolution (capped at MAX_TURNS)."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             turns = data.setdefault("turns", [])
             turns.append(turn)
             # Cap at max
@@ -132,7 +256,7 @@ class ProjectStore:
     def save_wonder_outcome(self, outcome: dict) -> None:
         """Save a Wonder session outcome (capped at MAX_WONDER_OUTCOMES)."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             outcomes = data.setdefault("wonder_outcomes", [])
             outcomes.append(outcome)
             if len(outcomes) > _MAX_WONDER_OUTCOMES:

package/mcp_server/persistence/taste_store.py

@@ -7,15 +7,31 @@ anti-preferences, and dimension weights. Located at
 
 from __future__ import annotations
 
+import logging
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Optional
 
 from .base_store import PersistentJsonStore
 
+logger = logging.getLogger(__name__)
+
 
 _DEFAULT_PATH = Path.home() / ".livepilot" / "taste.json"
 
+# Schema version of the on-disk shape this build writes/expects.
+CURRENT_VERSION = 1
+
+# Migration table: source version -> callable that upgrades data from that
+# version to the next. Empty today — CURRENT_VERSION has been 1 since this
+# store existed, so there has never been a real migration to run. This is
+# scaffolding: when a future schema bump lands, add `{OLD: _migrate_fn}` here
+# and bump CURRENT_VERSION. Without this table, ANY version mismatch (a
+# future bump, a downgrade, a hand-edited file) silently discarded the
+# user's entire taste/anti-preference history back to defaults with no
+# warning and no backup — that's the bug this scaffolding closes.
+_MIGRATIONS: dict[int, Callable[[dict], dict]] = {}
+
 
 class PersistentTasteStore:
     """Persistent backing for TasteGraph data."""
@@ -23,17 +39,84 @@ class PersistentTasteStore:
     def __init__(self, path: Optional[Path] = None):
         self._store = PersistentJsonStore(path or _DEFAULT_PATH)
 
+    def _coerce(self, data: dict) -> dict:
+        """Return schema-current data — migrating forward or resetting.
+
+        - version == CURRENT_VERSION: pass through unchanged (hot path).
+        - version has a registered migration chain to CURRENT_VERSION: run it.
+        - anything else (missing/non-int version, or a version this build
+          doesn't know how to migrate — e.g. it's newer than this build):
+          back up the raw file to ``<path>.pre-migration``, log a WARNING,
+          and fall back to defaults. Never silently discard.
+        """
+        version = data.get("version")
+        if version == CURRENT_VERSION:
+            return data
+        migrated = self._migrate(data, version)
+        if migrated is not None:
+            return migrated
+        if data:
+            self._backup_unmigrated(version)
+        return self._default()
+
+    @staticmethod
+    def _migrate(data: dict, version) -> Optional[dict]:
+        """Run the migration chain from ``version`` to CURRENT_VERSION.
+
+        Returns None if there's no registered path (unknown/future version),
+        signalling the caller to fall back to defaults.
+        """
+        if not isinstance(version, int):
+            return None
+        migrated = dict(data)
+        seen: set[int] = set()
+        while migrated.get("version") != CURRENT_VERSION:
+            v = migrated.get("version")
+            if not isinstance(v, int) or v in seen or v not in _MIGRATIONS:
+                return None
+            seen.add(v)
+            migrated = _MIGRATIONS[v](migrated)
+        return migrated
+
+    def _backup_unmigrated(self, version) -> None:
+        """Preserve the raw on-disk file before falling back to defaults."""
+        path = self._store.path
+        backup = path.with_suffix(path.suffix + ".pre-migration")
+        try:
+            if path.exists():
+                path.replace(backup)
+                logger.warning(
+                    "PersistentTasteStore: unrecognized schema version %r in "
+                    "%s (expected %r) — backed up to %s and falling back to "
+                    "defaults; the original data was NOT discarded",
+                    version, path, CURRENT_VERSION, backup,
+                )
+            else:
+                logger.warning(
+                    "PersistentTasteStore: unrecognized schema version %r "
+                    "(expected %r, no on-disk file to back up) — falling "
+                    "back to defaults",
+                    version, CURRENT_VERSION,
+                )
+        except OSError as exc:
+            logger.warning(
+                "PersistentTasteStore: failed to back up unrecognized-"
+                "version file %s (%s) — falling back to defaults without "
+                "a backup",
+                path, exc,
+            )
+
     def get_all(self) -> dict:
         """Get all persisted taste data."""
         data = self._store.read()
-        return data if data.get("version") == 1 else self._default()
+        return self._coerce(data)
 
     def record_move_outcome(
         self, move_id: str, family: str, kept: bool, score: float = 0.0,
     ) -> None:
         """Persist a move outcome."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             outcomes = data.setdefault("move_outcomes", {})
             entry = outcomes.setdefault(move_id, {
                 "family": family, "kept_count": 0, "undone_count": 0,
@@ -57,7 +140,7 @@ class PersistentTasteStore:
         field mirrors the "improve" band.
         """
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             # Ensure the per-mode dict exists (migrating from legacy shape).
             bands = data.get("novelty_bands")
             if not isinstance(bands, dict) or not bands:
@@ -78,7 +161,7 @@ class PersistentTasteStore:
     def record_device_use(self, device_name: str, positive: bool = True) -> None:
         """Persist device affinity."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             affinities = data.setdefault("device_affinities", {})
             entry = affinities.setdefault(device_name, {
                 "affinity": 0.0, "use_count": 0,
@@ -96,7 +179,7 @@ class PersistentTasteStore:
     def record_anti_preference(self, dimension: str, direction: str) -> None:
         """Persist an anti-preference."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             antis = data.setdefault("anti_preferences", [])
             existing = next(
                 (a for a in antis if a["dimension"] == dimension and a["direction"] == direction),
@@ -117,7 +200,7 @@ class PersistentTasteStore:
     def record_dimension_weight(self, dimension: str, value: float) -> None:
         """Persist a dimension weight update."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             data.setdefault("dimension_weights", {})[dimension] = round(value, 3)
             return data
         self._store.update(_update)

package/mcp_server/preview_studio/engine.py

@@ -8,29 +8,43 @@ from __future__ import annotations
 
 import hashlib
 import json
+import threading
 import time
 from typing import Optional
 
 from ..runtime.degradation import DegradationInfo
-from .models import PreviewSet, PreviewVariant
+from .models import PreviewSet, PreviewVariant, compute_session_fingerprint
 
 
 # ── In-memory store ───────────────────────────────────────────────
+#
+# _preview_sets is mutated from both threadpooled sync tools (e.g.
+# compare_preview_variants) and event-loop async tools (e.g.
+# commit_preview_variant) — two concurrent create_preview_set calls used to
+# be able to race in store_preview_set's check-then-evict loop: both read
+# the same `oldest_key`, both `del` it, and the second raised KeyError. One
+# module-level lock around the get/store/evict critical sections closes
+# that race.
 
 _preview_sets: dict[str, PreviewSet] = {}
+_preview_sets_lock = threading.Lock()
 _MAX_PREVIEW_SETS = 20
 
 
 def get_preview_set(set_id: str) -> Optional[PreviewSet]:
-    return _preview_sets.get(set_id)
+    with _preview_sets_lock:
+        return _preview_sets.get(set_id)
 
 
 def store_preview_set(ps: PreviewSet) -> None:
-    _preview_sets[ps.set_id] = ps
-    # Evict oldest sets if over limit
-    while len(_preview_sets) > _MAX_PREVIEW_SETS:
-        oldest_key = next(iter(_preview_sets))
-        del _preview_sets[oldest_key]
+    with _preview_sets_lock:
+        _preview_sets[ps.set_id] = ps
+        # Evict oldest sets if over limit
+        while len(_preview_sets) > _MAX_PREVIEW_SETS:
+            oldest_key = next(iter(_preview_sets), None)
+            if oldest_key is None:
+                break
+            _preview_sets.pop(oldest_key, None)
 
 
 # Statuses that represent work a user (or caller) has already invested in:
@@ -50,13 +64,13 @@ def _resolve_set_id(base_id: str) -> str:
     to a distinct, still-deterministic id (base_id + a monotonic suffix) so the
     protected set survives and the new set gets its own slot.
     """
-    existing = _preview_sets.get(base_id)
+    existing = get_preview_set(base_id)
     if existing is None or existing.status not in _PROTECTED_STATUSES:
         return base_id
     suffix = 2
     while True:
         candidate = f"{base_id}_b{suffix}"
-        occupant = _preview_sets.get(candidate)
+        occupant = get_preview_set(candidate)
         if occupant is None or occupant.status not in _PROTECTED_STATUSES:
             return candidate
         suffix += 1
@@ -86,6 +100,13 @@ def create_preview_set(
         synthesizes an empty-but-valid kernel (see ``_build_triptych``) and
         flags the resulting PreviewSet with ``degradation.is_degraded=True``
         so callers can tell a synthesized compile from a real one.
+
+        When kernel carries a real ``session_info`` (track topology), the
+        resulting PreviewSet is stamped with a session_fingerprint so a
+        later commit can detect that the session's track/device layout
+        changed since this plan's indices were compiled — no extra Ableton
+        round-trip is made here, we just hash data the caller already
+        fetched.
     """
     set_id = _resolve_set_id(_compute_set_id(request_text, kernel_id))
     now = int(time.time() * 1000)
@@ -117,6 +138,13 @@ def create_preview_set(
             request_text, moves, song_brain, taste_graph, set_id, now, kernel,
         )
 
+    # Stamp session identity from data the caller already fetched (kernel's
+    # session_info) — never a new round-trip. Absent/synthesized kernels
+    # yield "", which downstream commit checks treat as "no signal".
+    session_fingerprint = compute_session_fingerprint(
+        (kernel or {}).get("session_info")
+    )
+
     ps = PreviewSet(
         set_id=set_id,
         request_text=request_text,
@@ -125,6 +153,7 @@ def create_preview_set(
         variants=variants,
         created_at_ms=now,
         degradation=degradation,
+        session_fingerprint=session_fingerprint,
     )
     store_preview_set(ps)
     return ps
@@ -433,7 +462,8 @@ def commit_variant(preview_set: PreviewSet, variant_id: str) -> Optional[Preview
 
 def discard_set(set_id: str) -> bool:
     """Discard an entire preview set."""
-    ps = _preview_sets.pop(set_id, None)
+    with _preview_sets_lock:
+        ps = _preview_sets.pop(set_id, None)
     if ps:
         ps.status = "discarded"
         for v in ps.variants: