livepilot 1.9.14 → 1.9.16

package/mcp_server/evaluation/policy.py

@@ -0,0 +1,67 @@
+"""Policy — hard rule enforcement for all evaluators.
+
+Consistent keep/undo semantics shared across sonic, composition,
+and all future evaluators.
+
+Design: EVALUATION_FABRIC_V1.md, section 8
+"""
+
+from __future__ import annotations
+
+
+def apply_hard_rules(
+    goal_progress: float,
+    collateral_damage: float,
+    protection_violated: bool,
+    measurable_count: int,
+    score: float,
+    target_count: int,
+) -> tuple[bool, list[str]]:
+    """Enforce hard rules and return (keep_change, failure_reasons).
+
+    Rules (evaluated in order):
+    1. All targets unmeasurable + no protection violation -> defer to agent
+    2. Protection violated -> force undo
+    3. Measurable delta <= 0 when measurable targets exist -> force undo
+    4. Score < 0.40 -> force undo
+
+    Args:
+        goal_progress: weighted sum of dimension deltas
+        collateral_damage: max drop across protected dimensions
+        protection_violated: any protected dimension below threshold
+        measurable_count: how many target dimensions were measurable
+        score: composite quality score (0-1)
+        target_count: total number of target dimensions
+
+    Returns:
+        (keep_change, list_of_rule_failure_reasons)
+    """
+    failures: list[str] = []
+
+    # Rule 1: all unmeasurable + no protection violation -> defer
+    if measurable_count == 0 and not protection_violated:
+        return True, [
+            "No measurable target dimensions — deferring keep/undo "
+            "to agent musical judgment"
+        ]
+
+    # Rule 2: protection violated -> force undo
+    if protection_violated:
+        failures.append("HARD RULE: protected dimension violated")
+
+    # Rule 3: no measurable improvement -> force undo
+    if measurable_count > 0:
+        measurable_delta = goal_progress / max(measurable_count, 1)
+        if measurable_delta <= 0:
+            failures.append(
+                "HARD RULE: measurable delta <= 0 — no measurable improvement"
+            )
+
+    # Rule 4: score threshold -> force undo
+    if score < 0.40:
+        failures.append(
+            f"HARD RULE: total score {score:.3f} < 0.40 threshold"
+        )
+
+    keep_change = len(failures) == 0
+    return keep_change, failures

package/mcp_server/evaluation/tools.py

@@ -0,0 +1,53 @@
+"""Evaluation Fabric MCP tools — unified evaluation entry points.
+
+Provides evaluate_with_fabric as a generic evaluation tool that routes
+to the appropriate engine-specific evaluator via fabric.evaluate().
+"""
+
+from __future__ import annotations
+
+from mcp.server.fastmcp import Context
+
+from ..server import mcp
+from ..tools._evaluation_contracts import EvaluationRequest, EvaluationResult
+from ..tools._snapshot_normalizer import normalize_sonic_snapshot
+from . import fabric
+
+
+@mcp.tool()
+def evaluate_with_fabric(
+    ctx: Context,
+    engine: str,
+    before_snapshot: dict,
+    after_snapshot: dict,
+    targets: dict | None = None,
+    protect: dict | None = None,
+) -> dict:
+    """Evaluate a move using the unified Evaluation Fabric.
+
+    Routes to the appropriate engine-specific evaluator.
+
+    Args:
+        engine: "sonic", "composition", "mix", "transition", or "translation"
+        before_snapshot: State before the move (format depends on engine)
+        after_snapshot: State after the move (format depends on engine)
+        targets: Goal targets — for sonic: {dimension: weight}, ignored for others
+        protect: Protected dimensions — for sonic: {dimension: threshold}
+
+    Returns:
+        EvaluationResult as dict with score, keep_change, goal_progress,
+        collateral_damage, dimension_changes, notes, etc.
+    """
+    targets = targets or {}
+    protect = protect or {}
+
+    request = EvaluationRequest(
+        engine=engine or "sonic",
+        goal={"targets": targets},
+        before=before_snapshot,
+        after=after_snapshot,
+        protect=protect,
+    )
+
+    result = fabric.evaluate(request)
+    return result.to_dict()

package/mcp_server/m4l_bridge.py

@@ -338,13 +338,15 @@ class M4LBridge:
         self.receiver = receiver
         self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self._m4l_addr = ("127.0.0.1", 9881)
-        self._cmd_lock = asyncio.Lock()
+        self._cmd_lock: Optional[asyncio.Lock] = None
 
     async def send_command(self, command: str, *args: Any, timeout: float = 5.0) -> dict:
         """Send an OSC command to the M4L device and wait for the response."""
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        if self._cmd_lock is None:
+            self._cmd_lock = asyncio.Lock()
         async with self._cmd_lock:
             # Create a future for the response
             loop = asyncio.get_running_loop()
@@ -362,6 +364,10 @@ class M4LBridge:
                 result = await asyncio.wait_for(future, timeout=timeout)
                 return result
             except asyncio.TimeoutError:
+                # Clear the stale future so a delayed response doesn't resolve
+                # a future that no caller is waiting on
+                if self.receiver:
+                    self.receiver.set_response_future(None)
                 return {"error": "M4L bridge timeout — device may be busy or removed"}
 
     async def send_capture(self, command: str, *args: Any, timeout: float = 35.0) -> dict:
@@ -369,6 +375,8 @@ class M4LBridge:
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        if self._cmd_lock is None:
+            self._cmd_lock = asyncio.Lock()
         async with self._cmd_lock:
             # Cancel any stale capture future before creating a new one
             if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():

package/mcp_server/memory/__init__.py

@@ -1,5 +1,14 @@
-"""LivePilot technique memory — persistent storage for learned patterns."""
+"""Memory Fabric V2 — extended memory with anti-memory, promotion, session memory."""
 
 from .technique_store import TechniqueStore
+from .anti_memory import AntiMemoryStore, AntiPreference
+from .promotion import PromotionCandidate, evaluate_promotion, batch_evaluate_promotions
 
-__all__ = ["TechniqueStore"]
+__all__ = [
+    "TechniqueStore",
+    "AntiMemoryStore",
+    "AntiPreference",
+    "PromotionCandidate",
+    "evaluate_promotion",
+    "batch_evaluate_promotions",
+]

package/mcp_server/memory/anti_memory.py

@@ -0,0 +1,78 @@
+"""AntiMemory — tracks user dislikes and anti-preferences.
+
+Pure Python, zero I/O.  Records dimensions the user repeatedly rejects
+so that planners and critics can caution against repeating them.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+
+
+@dataclass
+class AntiPreference:
+    """A single anti-preference: something the user dislikes."""
+
+    dimension: str  # e.g. "brightness", "width", "density"
+    direction: str  # "increase" or "decrease"
+    strength: float = 0.0  # 0-1, how strongly disliked
+    evidence_count: int = 0  # how many times undone/rejected
+    last_seen_ms: int = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "dimension": self.dimension,
+            "direction": self.direction,
+            "strength": self.strength,
+            "evidence_count": self.evidence_count,
+            "last_seen_ms": self.last_seen_ms,
+        }
+
+
+class AntiMemoryStore:
+    """In-memory store for anti-preferences."""
+
+    def __init__(self) -> None:
+        self._prefs: dict[tuple[str, str], AntiPreference] = {}
+
+    def record_dislike(self, dimension: str, direction: str) -> AntiPreference:
+        """Record or increment an anti-preference.
+
+        Strength grows with evidence but caps at 1.0.
+        """
+        key = (dimension, direction)
+        pref = self._prefs.get(key)
+        if pref is None:
+            pref = AntiPreference(dimension=dimension, direction=direction)
+            self._prefs[key] = pref
+
+        pref.evidence_count += 1
+        # Strength: asymptotic growth toward 1.0
+        pref.strength = min(1.0, pref.evidence_count * 0.2)
+        pref.last_seen_ms = int(time.time() * 1000)
+        return pref
+
+    def get_anti_preferences(self) -> list[AntiPreference]:
+        """Return all active anti-preferences."""
+        return list(self._prefs.values())
+
+    def get_anti_preference(
+        self, dimension: str, direction: str
+    ) -> AntiPreference | None:
+        """Return a specific anti-preference, or None."""
+        return self._prefs.get((dimension, direction))
+
+    def should_caution(self, dimension: str, direction: str) -> bool:
+        """True if evidence_count >= 2 for the given dimension+direction."""
+        pref = self._prefs.get((dimension, direction))
+        if pref is None:
+            return False
+        return pref.evidence_count >= 2
+
+    def to_dict(self) -> dict:
+        """Serialize the full store."""
+        return {
+            "anti_preferences": [p.to_dict() for p in self._prefs.values()],
+            "count": len(self._prefs),
+        }

package/mcp_server/memory/promotion.py

@@ -0,0 +1,94 @@
+"""Promotion rules — decide which ledger entries deserve long-term memory.
+
+Pure Python, zero I/O.  Evaluates LedgerEntry dicts against promotion
+criteria and returns structured candidates.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class PromotionCandidate:
+    """A ledger entry evaluated for memory promotion."""
+
+    ledger_entry_id: str
+    engine: str
+    intent: str
+    score: float
+    dimension_improvements: dict = field(default_factory=dict)
+    eligible: bool = False
+    reason: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "ledger_entry_id": self.ledger_entry_id,
+            "engine": self.engine,
+            "intent": self.intent,
+            "score": self.score,
+            "dimension_improvements": dict(self.dimension_improvements),
+            "eligible": self.eligible,
+            "reason": self.reason,
+        }
+
+
+def evaluate_promotion(entry_dict: dict) -> PromotionCandidate:
+    """Evaluate a single ledger entry dict for memory promotion.
+
+    Rules:
+    - must be kept (kept=True)
+    - score >= 0.6
+    - at least one dimension improvement > 0.05
+    - non-empty intent
+    """
+    entry_id = entry_dict.get("id", "unknown")
+    engine = entry_dict.get("engine", "")
+    intent = entry_dict.get("intent", "")
+    score = entry_dict.get("score", 0.0)
+    kept = entry_dict.get("kept", False)
+
+    # Extract dimension improvements from evaluation sub-dict
+    evaluation = entry_dict.get("evaluation", {})
+    dimension_improvements = evaluation.get("dimension_improvements", {})
+
+    candidate = PromotionCandidate(
+        ledger_entry_id=entry_id,
+        engine=engine,
+        intent=intent,
+        score=score,
+        dimension_improvements=dimension_improvements,
+    )
+
+    # Rule 1: must be kept
+    if not kept:
+        candidate.reason = "not kept — entry was undone or rejected"
+        return candidate
+
+    # Rule 2: score threshold
+    if score < 0.6:
+        candidate.reason = f"score too low ({score:.2f} < 0.60)"
+        return candidate
+
+    # Rule 3: non-empty intent
+    if not intent or not intent.strip():
+        candidate.reason = "empty intent — no semantic goal recorded"
+        return candidate
+
+    # Rule 4: at least one meaningful dimension improvement
+    has_improvement = any(v > 0.05 for v in dimension_improvements.values())
+    if not has_improvement:
+        candidate.reason = "no dimension improvement > 0.05"
+        return candidate
+
+    # All rules pass
+    candidate.eligible = True
+    candidate.reason = "meets all promotion criteria"
+    return candidate
+
+
+def batch_evaluate_promotions(entries: list[dict]) -> list[PromotionCandidate]:
+    """Evaluate multiple entries, return only eligible ones."""
+    return [
+        c for c in (evaluate_promotion(e) for e in entries) if c.eligible
+    ]

package/mcp_server/memory/session_memory.py

@@ -0,0 +1,108 @@
+"""SessionMemory — ephemeral per-session observations, hypotheses, decisions.
+
+Pure Python, zero I/O.  Tracks what happened *this* session so that engines
+can reference recent context without polluting long-term memory.
+"""
+
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Optional
+
+_VALID_CATEGORIES = {"observation", "hypothesis", "decision", "issue"}
+
+
+@dataclass
+class SessionMemoryEntry:
+    """Ephemeral per-session memory — what happened this session."""
+
+    id: str
+    timestamp_ms: int
+    category: str  # "observation", "hypothesis", "decision", "issue"
+    content: str
+    engine: str  # which engine created this
+    confidence: float
+    related_tracks: list[int] = field(default_factory=list)
+    expires_with_session: bool = True
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "timestamp_ms": self.timestamp_ms,
+            "category": self.category,
+            "content": self.content,
+            "engine": self.engine,
+            "confidence": self.confidence,
+            "related_tracks": list(self.related_tracks),
+            "expires_with_session": self.expires_with_session,
+        }
+
+
+class SessionMemoryStore:
+    """In-memory store for session-scoped observations and decisions."""
+
+    def __init__(self) -> None:
+        self._entries: list[SessionMemoryEntry] = []
+
+    def add(
+        self,
+        category: str,
+        content: str,
+        engine: str,
+        confidence: float = 0.5,
+        tracks: Optional[list[int]] = None,
+    ) -> str:
+        """Add a session memory entry.  Returns the new entry id."""
+        if category not in _VALID_CATEGORIES:
+            raise ValueError(
+                f"category must be one of {_VALID_CATEGORIES}, got {category!r}"
+            )
+        confidence = max(0.0, min(1.0, confidence))
+
+        entry = SessionMemoryEntry(
+            id=f"smem_{uuid.uuid4().hex[:8]}",
+            timestamp_ms=int(time.time() * 1000),
+            category=category,
+            content=content,
+            engine=engine,
+            confidence=confidence,
+            related_tracks=list(tracks) if tracks else [],
+        )
+        self._entries.append(entry)
+        return entry.id
+
+    def get_recent(
+        self,
+        limit: int = 10,
+        category: Optional[str] = None,
+        engine: Optional[str] = None,
+    ) -> list[SessionMemoryEntry]:
+        """Return the most recent entries, optionally filtered."""
+        filtered = self._entries
+        if category:
+            filtered = [e for e in filtered if e.category == category]
+        if engine:
+            filtered = [e for e in filtered if e.engine == engine]
+        # Most recent first
+        return list(reversed(filtered))[:limit]
+
+    def get_by_tracks(self, track_indices: list[int]) -> list[SessionMemoryEntry]:
+        """Return entries related to any of the given track indices."""
+        idx_set = set(track_indices)
+        return [
+            e for e in self._entries
+            if idx_set.intersection(e.related_tracks)
+        ]
+
+    def clear(self) -> None:
+        """Wipe all session memory."""
+        self._entries.clear()
+
+    def to_dict(self) -> dict:
+        """Serialize the full store."""
+        return {
+            "entries": [e.to_dict() for e in self._entries],
+            "count": len(self._entries),
+        }

package/mcp_server/memory/taste_memory.py

@@ -0,0 +1,158 @@
+"""TasteMemory — extended taste tracking beyond quality dimensions.
+
+Pure Python, zero I/O.  Infers user taste from kept/undone outcomes
+across 8 production dimensions so that planners can bias toward preferences.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Optional
+
+
+EXTENDED_TASTE_DIMENSIONS = [
+    "transition_boldness",
+    "automation_density",
+    "dryness_preference",
+    "harmonic_boldness",
+    "width_preference",
+    "native_vs_plugin",
+    "density_tolerance",
+    "fx_intensity",
+]
+
+# Maps outcome signals to taste dimension adjustments.
+# Each key is a dimension name; values map (outcome_signal -> adjustment).
+_OUTCOME_SIGNALS: dict[str, dict[str, float]] = {
+    "transition_boldness": {
+        "bold_transition_kept": 0.15,
+        "bold_transition_undone": -0.15,
+        "subtle_transition_kept": -0.10,
+        "subtle_transition_undone": 0.10,
+    },
+    "automation_density": {
+        "dense_automation_kept": 0.12,
+        "dense_automation_undone": -0.12,
+        "sparse_automation_kept": -0.08,
+    },
+    "dryness_preference": {
+        "dry_mix_kept": 0.15,
+        "dry_mix_undone": -0.15,
+        "wet_mix_kept": -0.12,
+        "wet_mix_undone": 0.12,
+    },
+    "harmonic_boldness": {
+        "bold_harmony_kept": 0.15,
+        "bold_harmony_undone": -0.15,
+        "safe_harmony_kept": -0.10,
+    },
+    "width_preference": {
+        "wide_mix_kept": 0.12,
+        "wide_mix_undone": -0.12,
+        "narrow_mix_kept": -0.10,
+    },
+    "native_vs_plugin": {
+        "native_device_kept": 0.10,
+        "plugin_kept": -0.10,
+    },
+    "density_tolerance": {
+        "dense_arrangement_kept": 0.12,
+        "dense_arrangement_undone": -0.12,
+        "sparse_arrangement_kept": -0.08,
+    },
+    "fx_intensity": {
+        "heavy_fx_kept": 0.15,
+        "heavy_fx_undone": -0.15,
+        "light_fx_kept": -0.10,
+        "light_fx_undone": 0.10,
+    },
+}
+
+
+@dataclass
+class TasteDimension:
+    """Extended taste tracking beyond quality dimensions."""
+
+    name: str  # e.g. "transition_boldness", "automation_density"
+    value: float  # -1 to 1 (negative=prefers less, positive=prefers more)
+    evidence_count: int
+    last_updated_ms: int
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "value": round(self.value, 3),
+            "evidence_count": self.evidence_count,
+            "last_updated_ms": self.last_updated_ms,
+        }
+
+
+class TasteMemoryStore:
+    """In-memory store for taste dimensions inferred from outcomes."""
+
+    def __init__(self) -> None:
+        self._dims: dict[str, TasteDimension] = {}
+        # Initialize all known dimensions at neutral
+        for name in EXTENDED_TASTE_DIMENSIONS:
+            self._dims[name] = TasteDimension(
+                name=name, value=0.0, evidence_count=0, last_updated_ms=0
+            )
+
+    def update_from_outcome(self, outcome: dict) -> None:
+        """Infer taste dimensions from a kept/undone outcome dict.
+
+        The outcome dict should contain:
+          - kept: bool
+          - signals: list[str]  — e.g. ["bold_transition_kept", "wide_mix_kept"]
+        """
+        signals = outcome.get("signals", [])
+        if not signals:
+            return
+
+        now_ms = int(time.time() * 1000)
+
+        for signal in signals:
+            for dim_name, signal_map in _OUTCOME_SIGNALS.items():
+                adj = signal_map.get(signal)
+                if adj is not None:
+                    dim = self._dims.get(dim_name)
+                    if dim is None:
+                        dim = TasteDimension(
+                            name=dim_name, value=0.0,
+                            evidence_count=0, last_updated_ms=0,
+                        )
+                        self._dims[dim_name] = dim
+                    dim.value = max(-1.0, min(1.0, dim.value + adj))
+                    dim.evidence_count += 1
+                    dim.last_updated_ms = now_ms
+
+    def get_taste_dimensions(self) -> list[TasteDimension]:
+        """Return all taste dimensions."""
+        return list(self._dims.values())
+
+    def get_dimension(self, name: str) -> Optional[TasteDimension]:
+        """Return a specific taste dimension, or None."""
+        return self._dims.get(name)
+
+    def should_prefer(self, dimension: str, direction: str) -> bool:
+        """True if evidence suggests the user prefers this direction.
+
+        direction: "more" or "less"
+        Returns True only if evidence_count >= 2 and value agrees.
+        """
+        dim = self._dims.get(dimension)
+        if dim is None or dim.evidence_count < 2:
+            return False
+        if direction == "more":
+            return dim.value > 0.1
+        elif direction == "less":
+            return dim.value < -0.1
+        return False
+
+    def to_dict(self) -> dict:
+        """Serialize the full store."""
+        return {
+            "dimensions": [d.to_dict() for d in self._dims.values()],
+            "count": len(self._dims),
+        }

package/mcp_server/memory/technique_store.py

@@ -11,7 +11,8 @@ from typing import Any, Optional
 
 
 VALID_TYPES = frozenset(
-    ["beat_pattern", "device_chain", "mix_template", "browser_pin", "preference"]
+    ["beat_pattern", "device_chain", "mix_template", "browser_pin", "preference",
+     "outcome", "composition_outcome", "technique_card"]
 )
 
 VALID_SORT_FIELDS = frozenset(
@@ -36,28 +37,35 @@ class TechniqueStore:
 
         Deferred so that a read-only HOME doesn't crash the entire MCP
         server at import time — memory tools just return errors instead.
+        Thread-safe: uses double-checked locking to prevent concurrent
+        callers from racing on initialization.
         """
         if self._initialized:
             return
-        try:
-            self._base_dir.mkdir(parents=True, exist_ok=True)
-        except OSError as exc:
-            raise RuntimeError(
-                f"Cannot create memory directory {self._base_dir}: {exc}. "
-                "Memory tools are unavailable."
-            ) from exc
-        if self._file.exists():
+        with self._lock:
+            # Double-check after acquiring lock — another thread may have
+            # initialized while we were waiting.
+            if self._initialized:
+                return
             try:
-                with open(self._file, "r") as f:
-                    self._data = json.load(f)
-            except (json.JSONDecodeError, ValueError):
-                corrupt = self._file.with_suffix(".json.corrupt")
-                self._file.rename(corrupt)
+                self._base_dir.mkdir(parents=True, exist_ok=True)
+            except OSError as exc:
+                raise RuntimeError(
+                    f"Cannot create memory directory {self._base_dir}: {exc}. "
+                    "Memory tools are unavailable."
+                ) from exc
+            if self._file.exists():
+                try:
+                    with open(self._file, "r") as f:
+                        self._data = json.load(f)
+                except (json.JSONDecodeError, ValueError):
+                    corrupt = self._file.with_suffix(".json.corrupt")
+                    self._file.rename(corrupt)
+                    self._data = {"version": 1, "techniques": []}
+            else:
                 self._data = {"version": 1, "techniques": []}
-        else:
-            self._data = {"version": 1, "techniques": []}
-            self._flush()
-        self._initialized = True
+                self._flush()
+            self._initialized = True
 
     # ── persistence ──────────────────────────────────────────────
 
@@ -262,6 +270,7 @@ class TechniqueStore:
 
     def increment_replay(self, technique_id: str) -> None:
         """Increment replay_count and set last_replayed_at."""
+        self._ensure_initialized()
         with self._lock:
             t = self._find(technique_id)
             t["replay_count"] = t.get("replay_count", 0) + 1