livepilot 1.9.23 → 1.10.0

package/mcp_server/m4l_bridge.py

@@ -124,6 +124,7 @@ class SpectralCache:
             return result
 
 
+
 class SpectralReceiver(asyncio.DatagramProtocol):
     """Receives OSC-formatted UDP packets from the M4L device.
 

package/mcp_server/memory/taste_graph.py

@@ -99,6 +99,9 @@ class TasteGraph:
 
     # ── Update methods ───────────────────────────────────────────────
 
+    # Persistent store reference (set by build_taste_graph when available)
+    _persistent_store: object = None
+
     def record_move_outcome(
         self, move_id: str, family: str, kept: bool, score: float = 0.0
     ) -> None:
@@ -120,6 +123,13 @@ class TasteGraph:
         self.evidence_count += 1
         self.last_updated_ms = now
 
+        # Write-back to persistent store
+        if self._persistent_store is not None:
+            try:
+                self._persistent_store.record_move_outcome(move_id, family, kept, score)
+            except Exception:
+                pass  # persistence is best-effort
+
     def record_device_use(self, device_name: str, positive: bool = True) -> None:
         """Update device affinity from usage."""
         now = int(time.time() * 1000)
@@ -245,10 +255,17 @@ class TasteGraph:
 def build_taste_graph(
     taste_store=None,   # TasteMemoryStore
     anti_store=None,    # AntiMemoryStore
+    persistent_store=None,  # PersistentTasteStore (optional)
 ) -> TasteGraph:
-    """Build a TasteGraph from existing memory stores."""
+    """Build a TasteGraph from existing memory stores.
+
+    When persistent_store is provided, hydrates move_family_scores,
+    device_affinities, and novelty_band from disk — these survive
+    server restart.
+    """
     graph = TasteGraph()
 
+    # Session-scoped dimensions (in-memory)
     if taste_store:
         for dim in taste_store.get_taste_dimensions():
             if dim.evidence_count > 0:
@@ -258,4 +275,54 @@ def build_taste_graph(
         for pref in anti_store.get_anti_preferences():
             graph.dimension_avoidances[pref.dimension] = pref.direction
 
+    # Persistent state (from disk)
+    if persistent_store is not None:
+        persisted = persistent_store.get_all()
+
+        # Move family scores
+        for move_id, outcome in persisted.get("move_outcomes", {}).items():
+            family = outcome.get("family", "")
+            if family and family not in graph.move_family_scores:
+                from .taste_graph import MoveFamilyScore
+                graph.move_family_scores[family] = MoveFamilyScore(family=family)
+            if family:
+                fam = graph.move_family_scores[family]
+                fam.kept_count += outcome.get("kept_count", 0)
+                fam.undone_count += outcome.get("undone_count", 0)
+                total = fam.kept_count + fam.undone_count
+                if total > 0:
+                    fam.score = round((fam.kept_count - fam.undone_count) / total, 3)
+
+        # Novelty band
+        graph.novelty_band = persisted.get("novelty_band", 0.5)
+
+        # Device affinities
+        for dev_name, dev_data in persisted.get("device_affinities", {}).items():
+            from .taste_graph import DeviceAffinity
+            graph.device_affinities[dev_name] = DeviceAffinity(
+                device_name=dev_name,
+                affinity=dev_data.get("affinity", 0.0),
+                use_count=dev_data.get("use_count", 0),
+            )
+
+        # Evidence count
+        graph.evidence_count = max(
+            graph.evidence_count, persisted.get("evidence_count", 0)
+        )
+
+        # Dimension weights from persistent store (merged, session takes precedence)
+        for dim, val in persisted.get("dimension_weights", {}).items():
+            if dim not in graph.dimension_weights:
+                graph.dimension_weights[dim] = val
+
+        # Anti-preferences from persistent store
+        for anti in persisted.get("anti_preferences", []):
+            dim = anti.get("dimension", "")
+            direction = anti.get("direction", "")
+            if dim and dim not in graph.dimension_avoidances:
+                graph.dimension_avoidances[dim] = direction
+
+    # Attach persistent store for write-back
+    graph._persistent_store = persistent_store
+
     return graph

package/mcp_server/memory/tools.py

@@ -189,12 +189,23 @@ def record_positive_preference(
     not just what they dislike.
     """
     taste_store = _get_taste_memory(ctx)
-    # Map to outcome signal
-    signal = f"{dimension}_{direction}_kept"
-    taste_store.update_from_outcome({"signal": signal})
+    # Find matching outcome signals for this dimension+direction
+    from ..memory.taste_memory import _OUTCOME_SIGNALS
+    matching_signals = []
+    dim_signals = _OUTCOME_SIGNALS.get(dimension, {})
+    for sig_name, adjustment in dim_signals.items():
+        # "increase" preference → match positive-adjustment signals (kept)
+        # "decrease" preference → match negative-adjustment signals (undone/less)
+        if direction == "increase" and adjustment > 0:
+            matching_signals.append(sig_name)
+        elif direction == "decrease" and adjustment < 0:
+            matching_signals.append(sig_name)
+    if matching_signals:
+        taste_store.update_from_outcome({"signals": matching_signals})
     return {
-        "recorded": True,
+        "recorded": bool(matching_signals),
         "dimension": dimension,
         "direction": direction,
+        "signals_matched": matching_signals,
         "evidence": evidence,
     }

package/mcp_server/musical_intelligence/detectors.py

@@ -96,9 +96,22 @@ def detect_repetition_fatigue(
     # 3. Motif fatigue from motif_graph
     if motif_graph:
         motifs = motif_graph.get("motifs", [])
+        num_sections = max(1, len(scenes))
         for motif in motifs:
             fatigue_risk = motif.get("fatigue_risk", 0)
-            if fatigue_risk > 0.6:
+            recurrence = motif.get("recurrence", 0)
+
+            # Motif appearing in >60% of sections = fatigue signal
+            if recurrence > 0.6 and num_sections >= 3:
+                adjusted_fatigue = max(fatigue_risk, recurrence * 0.8)
+                report.issues.append({
+                    "type": "motif_overuse",
+                    "severity": round(adjusted_fatigue, 3),
+                    "detail": f"Motif {motif.get('name', motif.get('motif_id', '?'))} appears in {recurrence:.0%} of sections",
+                    "motif_id": motif.get("motif_id", motif.get("name", "")),
+                    "evidence": "motif_recurrence",
+                })
+            elif fatigue_risk > 0.6:
                 report.issues.append({
                     "type": "motif_overuse",
                     "severity": fatigue_risk,

package/mcp_server/musical_intelligence/tools.py

@@ -45,10 +45,14 @@ def detect_repetition_fatigue(ctx: Context) -> dict:
             "clips": row,
         })
 
-    # Try to get motif graph for deeper analysis
+    # Motif data — via shared motif service
     motif_graph = None
     try:
-        motif_graph = ableton.send_command("get_motif_graph")
+        from ..services.motif_service import get_motif_data, fetch_notes_from_ableton
+        session_info = ableton.send_command("get_session_info", {})
+        track_list = session_info.get("tracks", [])
+        notes_by_track = fetch_notes_from_ableton(ableton, track_list)
+        motif_graph = get_motif_data(notes_by_track)
     except Exception:
         pass
 
@@ -171,17 +175,16 @@ def analyze_phrase_arc(
     loudness_data = None
     spectrum_data = None
 
+    # Direct Python calls to perception engine — not TCP
     try:
-        loudness_data = ableton.send_command("analyze_loudness_offline", {
-            "file_path": file_path, "detail": "full",
-        })
+        from ..tools._perception_engine import compute_loudness
+        loudness_data = compute_loudness(file_path, detail="full")
     except Exception:
         pass
 
     try:
-        spectrum_data = ableton.send_command("analyze_spectrum_offline_internal", {
-            "file_path": file_path,
-        })
+        from ..tools._perception_engine import compute_spectral
+        spectrum_data = compute_spectral(file_path)
     except Exception:
         pass
 

package/mcp_server/persistence/__init__.py

@@ -0,0 +1 @@
+"""Persistent storage for LivePilot state that survives server restart."""

package/mcp_server/persistence/base_store.py

@@ -0,0 +1,82 @@
+"""Persistent JSON store with atomic writes and corruption recovery.
+
+Follows the TechniqueStore pattern: lazy init, atomic tmp+rename,
+fsync to disk, corruption recovery via .corrupt rename.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+from pathlib import Path
+
+
+class PersistentJsonStore:
+    """Thread-safe, crash-safe JSON file store."""
+
+    def __init__(self, path: Path):
+        self._path = Path(path)
+        self._lock = threading.RLock()
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def read(self) -> dict:
+        """Read the store. Returns {} if missing or corrupt."""
+        with self._lock:
+            if not self._path.exists():
+                return {}
+            try:
+                return json.loads(self._path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                corrupt = self._path.with_suffix(self._path.suffix + ".corrupt")
+                try:
+                    self._path.rename(corrupt)
+                except OSError:
+                    pass
+                return {}
+
+    def write(self, data: dict) -> None:
+        """Atomically write data to disk."""
+        with self._lock:
+            self._path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self._path.with_suffix(".tmp")
+            try:
+                with open(tmp, "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=2, default=str)
+                    f.flush()
+                    os.fsync(f.fileno())
+                os.replace(str(tmp), str(self._path))
+            except OSError:
+                try:
+                    tmp.unlink(missing_ok=True)
+                except OSError:
+                    pass
+                raise
+
+    def update(self, updater) -> dict:
+        """Read-modify-write atomically. updater(data) -> modified data."""
+        with self._lock:
+            data = self._read_unlocked()
+            data = updater(data)
+            self._write_unlocked(data)
+            return data
+
+    def _read_unlocked(self) -> dict:
+        if not self._path.exists():
+            return {}
+        try:
+            return json.loads(self._path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def _write_unlocked(self, data: dict) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self._path.with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, default=str)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(str(tmp), str(self._path))

package/mcp_server/persistence/project_store.py

@@ -0,0 +1,106 @@
+"""Per-project persistent state — threads, turns, Wonder outcomes.
+
+Stores session continuity data scoped to a project identity.
+Located at ~/.livepilot/projects/<hash>/state.json.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base_store import PersistentJsonStore
+
+
+_PROJECTS_DIR = Path.home() / ".livepilot" / "projects"
+_MAX_TURNS = 50
+_MAX_WONDER_OUTCOMES = 10
+
+
+def project_hash(session_info: dict) -> str:
+    """Compute a stable project fingerprint from session info.
+
+    Uses tempo + track count + sorted track names. This is imperfect
+    but stable enough for per-song state within a production session.
+    """
+    tempo = session_info.get("tempo", 120.0)
+    tracks = session_info.get("tracks", [])
+    track_names = sorted(t.get("name", "") for t in tracks if isinstance(t, dict))
+    seed = f"{tempo:.1f}|{len(tracks)}|{'|'.join(track_names)}"
+    return hashlib.sha256(seed.encode()).hexdigest()[:12]
+
+
+class ProjectStore:
+    """Persistent per-project state."""
+
+    def __init__(self, project_id: str, base_dir: Optional[Path] = None):
+        base = base_dir or _PROJECTS_DIR
+        self._store = PersistentJsonStore(base / project_id / "state.json")
+        self._project_id = project_id
+
+    @property
+    def project_id(self) -> str:
+        return self._project_id
+
+    def get_all(self) -> dict:
+        data = self._store.read()
+        return data if data.get("version") == 1 else self._default()
+
+    def save_thread(self, thread: dict) -> None:
+        """Save or update a creative thread."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            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)
+            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()
+            turns = data.setdefault("turns", [])
+            turns.append(turn)
+            # Cap at max
+            if len(turns) > _MAX_TURNS:
+                data["turns"] = turns[-_MAX_TURNS:]
+            data["last_updated_ms"] = int(time.time() * 1000)
+            return data
+        self._store.update(_update)
+
+    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()
+            outcomes = data.setdefault("wonder_outcomes", [])
+            outcomes.append(outcome)
+            if len(outcomes) > _MAX_WONDER_OUTCOMES:
+                data["wonder_outcomes"] = outcomes[-_MAX_WONDER_OUTCOMES:]
+            return data
+        self._store.update(_update)
+
+    def get_threads(self) -> list[dict]:
+        return self.get_all().get("threads", [])
+
+    def get_turns(self) -> list[dict]:
+        return self.get_all().get("turns", [])
+
+    def get_wonder_outcomes(self) -> list[dict]:
+        return self.get_all().get("wonder_outcomes", [])
+
+    @staticmethod
+    def _default() -> dict:
+        return {
+            "version": 1,
+            "threads": [],
+            "turns": [],
+            "wonder_outcomes": [],
+            "last_updated_ms": 0,
+        }

package/mcp_server/persistence/taste_store.py

@@ -0,0 +1,122 @@
+"""Persistent taste state — survives server restart.
+
+Stores move outcomes, novelty preference, device affinity,
+anti-preferences, and dimension weights. Located at
+~/.livepilot/taste.json.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Optional
+
+from .base_store import PersistentJsonStore
+
+
+_DEFAULT_PATH = Path.home() / ".livepilot" / "taste.json"
+
+
+class PersistentTasteStore:
+    """Persistent backing for TasteGraph data."""
+
+    def __init__(self, path: Optional[Path] = None):
+        self._store = PersistentJsonStore(path or _DEFAULT_PATH)
+
+    def get_all(self) -> dict:
+        """Get all persisted taste data."""
+        data = self._store.read()
+        return data if data.get("version") == 1 else self._default()
+
+    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()
+            outcomes = data.setdefault("move_outcomes", {})
+            entry = outcomes.setdefault(move_id, {
+                "family": family, "kept_count": 0, "undone_count": 0,
+            })
+            entry["family"] = family
+            if kept:
+                entry["kept_count"] = entry.get("kept_count", 0) + 1
+            else:
+                entry["undone_count"] = entry.get("undone_count", 0) + 1
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            data["last_updated_ms"] = int(time.time() * 1000)
+            return data
+        self._store.update(_update)
+
+    def update_novelty(self, chose_bold: bool) -> None:
+        """Update novelty band from experiment choice."""
+        def _update(data: dict) -> dict:
+            data = data if data.get("version") == 1 else self._default()
+            band = data.get("novelty_band", 0.5)
+            if chose_bold:
+                data["novelty_band"] = min(1.0, band + 0.05)
+            else:
+                data["novelty_band"] = max(0.0, band - 0.05)
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            return data
+        self._store.update(_update)
+
+    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()
+            affinities = data.setdefault("device_affinities", {})
+            entry = affinities.setdefault(device_name, {
+                "affinity": 0.0, "use_count": 0,
+            })
+            entry["use_count"] = entry.get("use_count", 0) + 1
+            aff = entry.get("affinity", 0.0)
+            if positive:
+                entry["affinity"] = min(1.0, aff + 0.05)
+            else:
+                entry["affinity"] = max(-1.0, aff - 0.08)
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            return data
+        self._store.update(_update)
+
+    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()
+            antis = data.setdefault("anti_preferences", [])
+            existing = next(
+                (a for a in antis if a["dimension"] == dimension and a["direction"] == direction),
+                None,
+            )
+            if existing:
+                existing["count"] = existing.get("count", 0) + 1
+                existing["strength"] = min(1.0, existing["count"] * 0.2)
+            else:
+                antis.append({
+                    "dimension": dimension, "direction": direction,
+                    "count": 1, "strength": 0.2,
+                })
+            data["evidence_count"] = data.get("evidence_count", 0) + 1
+            return data
+        self._store.update(_update)
+
+    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.setdefault("dimension_weights", {})[dimension] = round(value, 3)
+            return data
+        self._store.update(_update)
+
+    @staticmethod
+    def _default() -> dict:
+        return {
+            "version": 1,
+            "move_outcomes": {},
+            "novelty_band": 0.5,
+            "device_affinities": {},
+            "anti_preferences": [],
+            "dimension_weights": {},
+            "evidence_count": 0,
+            "last_updated_ms": 0,
+        }

package/mcp_server/preview_studio/models.py

@@ -35,6 +35,7 @@ class PreviewVariant:
 
     # State
     status: str = "pending"  # pending, rendered, committed, discarded
+    preview_mode: str = ""  # audible_preview, metadata_only_preview, analytical_preview
     created_at_ms: int = 0
 
     def to_dict(self) -> dict:

package/mcp_server/preview_studio/tools.py

@@ -154,15 +154,20 @@ def create_preview_set(
             import sys
             print(f"LivePilot: SongBrain unavailable in preview_studio: {_e}", file=sys.stderr)
 
-    # Get taste graph — use session-scoped stores, extract numeric weights
+    # Get taste graph — session + persistent stores
     taste_graph: dict = {}
     try:
         from ..memory.taste_graph import build_taste_graph
         from ..memory.taste_memory import TasteMemoryStore
         from ..memory.anti_memory import AntiMemoryStore
+        from ..persistence.taste_store import PersistentTasteStore
         taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
         anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
-        graph = build_taste_graph(taste_store=taste_store, anti_store=anti_store)
+        persistent = ctx.lifespan_context.setdefault("persistent_taste", PersistentTasteStore())
+        graph = build_taste_graph(
+            taste_store=taste_store, anti_store=anti_store,
+            persistent_store=persistent,
+        )
         taste_graph = graph.to_dict()
     except Exception:
         pass
@@ -269,14 +274,19 @@ def commit_preview_variant(
         except Exception:
             pass
 
-        # Update taste graph
+        # Update taste graph (with persistent backing)
         try:
             from ..memory.taste_graph import build_taste_graph
             from ..memory.taste_memory import TasteMemoryStore
             from ..memory.anti_memory import AntiMemoryStore
+            from ..persistence.taste_store import PersistentTasteStore
             taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
             anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
-            graph = build_taste_graph(taste_store=taste_store, anti_store=anti_store)
+            persistent = ctx.lifespan_context.setdefault("persistent_taste", PersistentTasteStore())
+            graph = build_taste_graph(
+                taste_store=taste_store, anti_store=anti_store,
+                persistent_store=persistent,
+            )
             # Look up family from WonderSession's variant list
             family = ""
             for v in ws.variants:
@@ -349,18 +359,17 @@ def render_preview_variant(
         # compiled_plan may be a list (from semantic moves) or a dict with "steps" key
         plan = variant.compiled_plan
         steps = plan if isinstance(plan, list) else plan.get("steps", [])
+
+        from ..runtime.execution_router import execute_plan_steps
+
         applied_count = 0
         try:
             # Capture before state
             before_info = ableton.send_command("get_session_info", {})
 
-            # Apply the plan steps, tracking how many succeed
-            for step in steps:
-                cmd = step.get("tool") or step.get("command")
-                args = step.get("params") or step.get("args", {})
-                if cmd:
-                    ableton.send_command(cmd, args)
-                    applied_count += 1
+            # Execute through unified router
+            exec_results = execute_plan_steps(steps, ableton=ableton, ctx=ctx)
+            applied_count = sum(1 for r in exec_results if r.ok)
 
             # Capture after state
             after_info = ableton.send_command("get_session_info", {})
@@ -374,29 +383,63 @@ def render_preview_variant(
                 except Exception:
                     break
 
+        # Determine preview mode: audible (M4L available) or metadata-only
+        preview_mode = "metadata_only_preview"
+        spectral_before = None
+        spectral_after = None
+
+        # Try audible preview — capture spectrum via M4L spectral cache
+        try:
+            from ..m4l_bridge import SpectralCache
+            cache = ctx.lifespan_context.get("spectral")
+            if cache and isinstance(cache, SpectralCache) and cache.is_connected:
+                spectral_before = cache.get_all()
+                # Play for the requested bar count
+                tempo = before_info.get("tempo", 120)
+                play_seconds = bars * (60.0 / tempo) * 4  # bars * beat_duration * 4 beats
+                ableton.send_command("start_playback", {})
+                import time as _time
+                _time.sleep(min(play_seconds, 8.0))  # cap at 8 seconds
+                spectral_after = cache.get_all()
+                ableton.send_command("stop_playback", {})
+                preview_mode = "audible_preview"
+        except Exception:
+            pass  # fall back to metadata_only
+
         variant.status = "rendered"
+        variant.preview_mode = preview_mode
         variant.render_ref = f"render_{variant_id}_{bars}bars"
 
-        return {
+        result = {
             "rendered": True,
             "variant_id": variant_id,
             "label": variant.label,
             "bars": bars,
+            "preview_mode": preview_mode,
             "before_summary": {"tempo": before_info.get("tempo"), "tracks": before_info.get("track_count")},
             "after_summary": {"tempo": after_info.get("tempo"), "tracks": after_info.get("track_count")},
             "identity_effect": variant.identity_effect,
             "what_changed": variant.what_changed,
             "what_preserved": variant.what_preserved,
         }
+
+        if spectral_before and spectral_after:
+            result["spectral_comparison"] = {
+                "before": spectral_before,
+                "after": spectral_after,
+            }
+
+        return result
     else:
         # Analytical preview — no live render
         variant.status = "rendered"
+        variant.preview_mode = "analytical_preview"
         return {
             "rendered": True,
             "variant_id": variant_id,
             "label": variant.label,
             "bars": bars,
-            "mode": "analytical",
+            "preview_mode": "analytical_preview",
             "intent": variant.intent,
             "novelty_level": variant.novelty_level,
             "identity_effect": variant.identity_effect,