livepilot 1.9.23 → 1.9.24

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_cache")
+            if cache and isinstance(cache, SpectralCache) and cache.has_data():
+                spectral_before = cache.get_snapshot()
+                # 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_snapshot()
+                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,

package/mcp_server/runtime/capability.py

@@ -0,0 +1,66 @@
+"""Capability and degradation reporting for advanced tools.
+
+Every advanced tool reports its operational state so callers know
+what data was available, what was missing, and how much to trust
+the result.
+
+Levels:
+  full — all required data sources available
+  fallback — some data missing, result is degraded but useful
+  analytical_only — no live data, pure heuristic
+  unavailable — cannot operate at all
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class CapabilityReport:
+    """Operational state of an advanced tool invocation."""
+
+    level: str = "full"  # full, fallback, analytical_only, unavailable
+    confidence: float = 1.0
+    available_sources: list[str] = field(default_factory=list)
+    missing_sources: list[str] = field(default_factory=list)
+    fallback_used: str = ""
+    reason: str = ""
+
+    def to_dict(self) -> dict:
+        d = {"capability": self.level, "confidence": round(self.confidence, 2)}
+        if self.missing_sources:
+            d["missing"] = self.missing_sources
+        if self.fallback_used:
+            d["fallback"] = self.fallback_used
+        if self.reason:
+            d["reason"] = self.reason
+        return d
+
+
+def build_capability(
+    required: list[str],
+    available: dict[str, bool],
+) -> CapabilityReport:
+    """Build a capability report from required vs available data sources."""
+    missing = [r for r in required if not available.get(r, False)]
+    present = [r for r in required if available.get(r, False)]
+
+    if not missing:
+        return CapabilityReport(
+            level="full", confidence=1.0, available_sources=present,
+        )
+
+    if len(missing) == len(required):
+        return CapabilityReport(
+            level="analytical_only", confidence=0.2,
+            available_sources=[], missing_sources=missing,
+            reason="No required data sources available",
+        )
+
+    ratio = len(present) / len(required)
+    return CapabilityReport(
+        level="fallback", confidence=round(ratio * 0.8, 2),
+        available_sources=present, missing_sources=missing,
+        fallback_used="degraded inference from partial data",
+    )

package/mcp_server/runtime/capability_probe.py

@@ -0,0 +1,118 @@
+"""Runtime capability probe — detects what's available at startup.
+
+Reports capability tiers: Core Control, Analyzer-Enhanced,
+Offline Analysis, Creative Intelligence, Persistent Memory.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+
+def probe_capabilities(
+    ableton: Any = None,
+    ctx: Any = None,
+) -> dict:
+    """Probe runtime capabilities and return a structured report.
+
+    Can be called at startup or on demand via --doctor.
+    """
+    report: dict[str, dict] = {}
+
+    # 1. Ableton reachability
+    ableton_ok = False
+    if ableton is not None:
+        try:
+            info = ableton.send_command("ping")
+            ableton_ok = info is not None
+        except Exception:
+            pass
+    report["ableton"] = {
+        "status": "ok" if ableton_ok else "unavailable",
+        "detail": "TCP 9878 connection active" if ableton_ok else "Not connected",
+    }
+
+    # 2. Remote Script parity
+    from .remote_commands import REMOTE_COMMANDS
+    report["remote_script"] = {
+        "status": "ok",
+        "command_count": len(REMOTE_COMMANDS),
+        "detail": f"{len(REMOTE_COMMANDS)} registered commands",
+    }
+
+    # 3. M4L bridge
+    bridge_ok = False
+    if ctx is not None:
+        bridge = getattr(ctx, "lifespan_context", {}).get("m4l_bridge") if hasattr(ctx, "lifespan_context") else None
+        bridge_ok = bridge is not None
+    report["m4l_bridge"] = {
+        "status": "ok" if bridge_ok else "unavailable",
+        "detail": "UDP 9880 / OSC 9881 active" if bridge_ok else "Not connected — 30 analyzer tools unavailable",
+    }
+
+    # 4. Offline perception
+    numpy_ok = False
+    try:
+        import numpy  # noqa: F401
+        numpy_ok = True
+    except ImportError:
+        pass
+    report["offline_perception"] = {
+        "status": "ok" if numpy_ok else "degraded",
+        "detail": "numpy available" if numpy_ok else "numpy not installed — offline analysis unavailable",
+    }
+
+    # 5. Persistence
+    livepilot_dir = Path.home() / ".livepilot"
+    persistence_ok = livepilot_dir.exists() and os.access(livepilot_dir, os.W_OK)
+    taste_exists = (livepilot_dir / "taste.json").exists()
+    techniques_exists = (livepilot_dir / "memory" / "techniques.json").exists()
+    report["persistence"] = {
+        "status": "ok" if persistence_ok else "unavailable",
+        "detail": f"~/.livepilot/ {'writable' if persistence_ok else 'not found'}",
+        "taste_store": taste_exists,
+        "technique_store": techniques_exists,
+    }
+
+    # 6. Capability tier — highest active tier
+    if ableton_ok and bridge_ok:
+        tier = "analyzer_enhanced"
+    elif ableton_ok:
+        tier = "core_control"
+    else:
+        tier = "creative_intelligence"  # heuristic-only, no Ableton connection
+
+    report["tier"] = {
+        "active": tier,
+        "levels": {
+            "core_control": ableton_ok,
+            "analyzer_enhanced": ableton_ok and bridge_ok,
+            "offline_analysis": numpy_ok,
+            "creative_intelligence": True,  # always available
+            "persistent_memory": persistence_ok,
+        },
+    }
+
+    return report
+
+
+def format_doctor_report(report: dict) -> str:
+    """Format capability report for --doctor output."""
+    lines = ["LivePilot Capability Report", "=" * 40]
+
+    icons = {"ok": "  PASS", "unavailable": "  FAIL", "degraded": "  WARN"}
+
+    for area in ["ableton", "remote_script", "m4l_bridge", "offline_perception", "persistence"]:
+        info = report.get(area, {})
+        status = info.get("status", "unknown")
+        icon = icons.get(status, "  ????")
+        detail = info.get("detail", "")
+        lines.append(f"{icon}  {area}: {detail}")
+
+    tier = report.get("tier", {}).get("active", "unknown")
+    lines.append("")
+    lines.append(f"Active tier: {tier}")
+
+    return "\n".join(lines)