livepilot 1.9.24 → 1.10.1

package/mcp_server/server.py

@@ -40,13 +40,60 @@ def _identify_port_holder(port: int) -> str | None:
         return None
 
 
+def _master_has_livepilot_analyzer(ableton: AbletonConnection) -> bool:
+    """Check whether the analyzer device is currently on the master track."""
+    try:
+        track = ableton.send_command("get_master_track")
+    except Exception:
+        return False
+
+    devices = track.get("devices", []) if isinstance(track, dict) else []
+    for device in devices:
+        normalized = " ".join(
+            str(device.get("name") or "").replace("_", " ").replace("-", " ").lower().split()
+        )
+        if normalized == "livepilot analyzer":
+            return True
+    return False
+
+
+async def _warm_analyzer_bridge(
+    ableton: AbletonConnection,
+    spectral: SpectralCache,
+    timeout: float = 3.0,
+) -> None:
+    """Give the analyzer stream a short startup window before first use."""
+    if not _master_has_livepilot_analyzer(ableton):
+        return
+
+    loop = asyncio.get_running_loop()
+    deadline = loop.time() + max(timeout, 0.0)
+    while loop.time() < deadline:
+        if spectral.is_connected:
+            return
+        await asyncio.sleep(0.05)
+
+
 @asynccontextmanager
 async def lifespan(server):
-    """Create and yield the shared AbletonConnection + M4L bridge."""
+    """Create and yield the shared AbletonConnection + M4L bridge + registries."""
+    from .runtime.mcp_dispatch import build_mcp_dispatch_registry
+    from .splice_client.client import SpliceGRPCClient
+
     ableton = AbletonConnection()
     spectral = SpectralCache()
     receiver = SpectralReceiver(spectral)
     m4l = M4LBridge(spectral, receiver)
+    mcp_dispatch = build_mcp_dispatch_registry()
+
+    # Splice gRPC client — graceful degradation if Splice desktop isn't
+    # running or grpcio isn't installed. .connected will be False in that
+    # case and sample_resolver treats it as "no splice hits".
+    splice_client = SpliceGRPCClient()
+    try:
+        await splice_client.connect()
+    except Exception:
+        pass  # client remains in disconnected state
 
     # Start UDP listener for incoming M4L spectral data (port 9880)
     loop = asyncio.get_running_loop()
@@ -80,17 +127,25 @@ async def lifespan(server):
     }
 
     try:
+        if bridge_state["transport"] is not None:
+            await _warm_analyzer_bridge(ableton, spectral)
         yield {
             "ableton": ableton,
             "spectral": spectral,
             "m4l": m4l,
             "_bridge_state": bridge_state,
+            "mcp_dispatch": mcp_dispatch,
+            "splice_client": splice_client,
         }
     finally:
         if bridge_state["transport"]:
             bridge_state["transport"].close()
         m4l.close()
         ableton.disconnect()
+        try:
+            await splice_client.disconnect()
+        except Exception:
+            pass
 
 
 mcp = FastMCP("LivePilot", lifespan=lifespan)
@@ -140,6 +195,10 @@ from .stuckness_detector import tools as stuckness_tools       # noqa: F401, E40
 from .wonder_mode import tools as wonder_mode_tools            # noqa: F401, E402
 from .session_continuity import tools as session_cont_tools    # noqa: F401, E402
 from .creative_constraints import tools as constraints_tools   # noqa: F401, E402
+from .device_forge import tools as device_forge_tools          # noqa: F401, E402
+from .sample_engine import tools as sample_engine_tools        # noqa: F401, E402
+from .atlas import tools as atlas_tools                        # noqa: F401, E402
+from .composer import tools as composer_tools                  # noqa: F401, E402
 
 
 # ---------------------------------------------------------------------------
@@ -170,6 +229,14 @@ def _coerce_schema_property(prop: dict) -> None:
     # Recurse into array items so list[int]/list[float] params also accept strings
     if "items" in prop and isinstance(prop["items"], dict):
         _coerce_schema_property(prop["items"])
+    if "properties" in prop and isinstance(prop["properties"], dict):
+        for nested in prop["properties"].values():
+            if isinstance(nested, dict):
+                _coerce_schema_property(nested)
+    if "$defs" in prop and isinstance(prop["$defs"], dict):
+        for nested in prop["$defs"].values():
+            if isinstance(nested, dict):
+                _coerce_schema_property(nested)
 
 
 def _get_all_tools():
@@ -202,6 +269,9 @@ def _patch_tool_schemas() -> None:
             if name == "ctx":
                 continue  # skip the Context parameter
             _coerce_schema_property(prop)
+        for definition in tool.parameters.get("$defs", {}).values():
+            if isinstance(definition, dict):
+                _coerce_schema_property(definition)
 
 
 _patch_tool_schemas()

package/mcp_server/session_continuity/tracker.py

@@ -210,7 +210,10 @@ def rank_by_taste_and_identity(
         identity_effect = candidate.get("identity_effect", "preserves")
 
         # Taste score — how well does this fit cross-session preferences?
-        boldness_pref = taste_graph.get("transition_boldness", 0.5)
+        # Routed through the canonical accessor so dimension_weights.transition_boldness
+        # is honored. Previously read the top-level key directly and always got 0.5.
+        from ..memory.taste_accessors import get_dimension_pref
+        boldness_pref = get_dimension_pref(taste_graph, "transition_boldness", default=0.5)
         taste_score = 1.0 - abs(novelty - boldness_pref) * 0.8
         taste_score = round(max(0.0, min(1.0, taste_score)), 3)
 

package/mcp_server/sound_design/critics.py

@@ -281,17 +281,105 @@ def run_layer_overlap_critic(
     return issues
 
 
+# ── Corpus Intelligence Critic ──────────────────────────────────────
+
+
+def run_corpus_critic(
+    patch: PatchModel,
+    goal: TimbralGoalVector,
+) -> list[SoundDesignIssue]:
+    """Use the device-knowledge corpus to flag missed opportunities.
+
+    Checks each device in the chain against the corpus for known
+    techniques, parameter sweet spots, and creative possibilities
+    that the current patch doesn't exploit.
+    """
+    try:
+        from ..corpus import get_corpus
+    except ImportError:
+        return []
+
+    corpus = get_corpus()
+    if not corpus.emotional_recipes and not corpus.device_knowledge:
+        return []  # Corpus not loaded
+
+    issues: list[SoundDesignIssue] = []
+
+    # Check if any device in the chain has corpus knowledge
+    for block in patch.blocks:
+        dk = corpus.get_device(block.device_name)
+        if dk and dk.techniques and block.block_type == "oscillator":
+            # Oscillator with known techniques — suggest if patch is simple
+            has_character_block = any(
+                b.block_type in ("saturation", "spectral")
+                for b in patch.blocks
+            )
+            if not has_character_block and len(dk.techniques) > 2:
+                issues.append(SoundDesignIssue(
+                    issue_type="corpus_technique_available",
+                    critic="corpus",
+                    severity=0.25,
+                    confidence=0.6,
+                    affected_blocks=[block.device_name],
+                    evidence=(
+                        f"Corpus has {len(dk.techniques)} known techniques "
+                        f"for {block.device_name} but chain lacks character "
+                        f"processing (saturation/spectral). First technique: "
+                        f"{dk.techniques[0][:80]}"
+                    ),
+                    recommended_moves=["modulation_injection", "filter_contour"],
+                ))
+
+    # Check if goal maps to a known emotional recipe
+    emotion_map = {
+        "warmth": ("warmth", goal.warmth),
+        "brightness": ("euphoria", goal.brightness),
+        "instability": ("tension", goal.instability),
+        "softness": ("melancholy", goal.softness),
+    }
+    for quality, (emotion_key, goal_value) in emotion_map.items():
+        if goal_value > 0.3:
+            recipe = corpus.suggest_for_emotion(emotion_key)
+            if recipe and recipe.techniques:
+                # Check if any corpus technique device is in the chain
+                chain_names_lower = {d.lower() for d in patch.device_chain}
+                recipe_devices = set()
+                for tech in recipe.techniques:
+                    # Extract bold device names from technique strings
+                    for match in re.finditer(r"\*\*(.+?)\*\*", tech):
+                        recipe_devices.add(match.group(1).lower())
+
+                missing = recipe_devices - chain_names_lower
+                if missing and len(missing) <= 3:
+                    issues.append(SoundDesignIssue(
+                        issue_type="corpus_emotion_opportunity",
+                        critic="corpus",
+                        severity=0.2,
+                        confidence=0.5,
+                        affected_blocks=list(missing)[:3],
+                        evidence=(
+                            f"Goal wants {quality}={goal_value:.2f}. "
+                            f"Corpus '{recipe.emotion}' recipe suggests "
+                            f"devices not in chain: {', '.join(list(missing)[:3])}"
+                        ),
+                        recommended_moves=["filter_contour", "modulation_injection"],
+                    ))
+
+    return issues
+
+
 # ── Run all critics ──────────────────────────────────────────────────
 
 
 def run_all_sound_design_critics(
     state: SoundDesignState,
 ) -> list[SoundDesignIssue]:
-    """Run all five critics and aggregate issues."""
+    """Run all six critics and aggregate issues."""
     issues: list[SoundDesignIssue] = []
     issues.extend(run_static_timbre_critic(state.patch, state.goal))
     issues.extend(run_weak_identity_critic(state.patch))
     issues.extend(run_masking_role_critic(state.patch, state.layers))
     issues.extend(run_modulation_flatness_critic(state.patch))
     issues.extend(run_layer_overlap_critic(state.layers))
+    issues.extend(run_corpus_critic(state.patch, state.goal))
     return issues

package/mcp_server/splice_client/__init__.py

@@ -0,0 +1 @@
+"""Splice gRPC client — connect to Splice desktop's local API for sample search and download."""

package/mcp_server/splice_client/client.py

@@ -0,0 +1,347 @@
+"""SpliceGRPCClient — connect to Splice desktop's local gRPC API.
+
+Splice runs a gRPC server (Go binary) on localhost with TLS.
+Port is dynamic (read from port.conf). Certs are self-signed.
+
+This client provides: search, download, sample info, credit check.
+All methods are async. Graceful degradation when Splice is not running.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import glob
+import logging
+import os
+from typing import Optional
+
+from .models import SpliceCredits, SpliceSample, SpliceSearchResult
+
+logger = logging.getLogger(__name__)
+
+# Splice app support directory
+_SPLICE_APP_SUPPORT = os.path.expanduser(
+    "~/Library/Application Support/com.splice.Splice"
+)
+
+# Credit safety floor — never drain below this
+CREDIT_HARD_FLOOR = 5
+
+
+def _try_import_grpc():
+    """Import grpcio lazily — graceful degradation if not installed."""
+    try:
+        import grpc
+        return grpc
+    except ImportError:
+        return None
+
+
+def _try_import_protos():
+    """Import generated protobuf stubs lazily."""
+    try:
+        from .protos import app_pb2, app_pb2_grpc
+        return app_pb2, app_pb2_grpc
+    except ImportError:
+        return None, None
+
+
+class SpliceGRPCClient:
+    """Async gRPC client for Splice desktop's App service."""
+
+    def __init__(self):
+        self.channel = None
+        self.stub = None
+        self.connected = False
+        self._port: Optional[int] = None
+        self._grpc = _try_import_grpc()
+        self._pb2, self._pb2_grpc = _try_import_protos()
+
+    @property
+    def available(self) -> bool:
+        """True if grpcio is installed and Splice app support exists."""
+        return (
+            self._grpc is not None
+            and self._pb2 is not None
+            and os.path.isdir(_SPLICE_APP_SUPPORT)
+        )
+
+    async def connect(self) -> bool:
+        """Connect to Splice's local gRPC server. Returns True on success."""
+        if not self.available:
+            logger.info("Splice gRPC not available (grpcio missing or Splice not installed)")
+            return False
+
+        port = self._read_port()
+        if not port:
+            logger.info("Cannot read Splice port from port.conf")
+            return False
+
+        cert_pem = self._read_cert()
+        if not cert_pem:
+            logger.info("Cannot read Splice TLS certificate")
+            return False
+
+        try:
+            grpc = self._grpc
+            credentials = grpc.ssl_channel_credentials(root_certificates=cert_pem)
+            self.channel = grpc.aio.secure_channel(
+                f"127.0.0.1:{port}", credentials
+            )
+            self.stub = self._pb2_grpc.AppStub(self.channel)
+            self._port = port
+            self.connected = True
+            logger.info(f"Connected to Splice gRPC on port {port}")
+            return True
+        except Exception as exc:
+            logger.warning(f"Failed to connect to Splice: {exc}")
+            self.connected = False
+            return False
+
+    async def disconnect(self):
+        """Close the gRPC channel."""
+        if self.channel:
+            await self.channel.close()
+            self.channel = None
+            self.stub = None
+            self.connected = False
+
+    # ── Search ──────────────────────────────────────────────────────
+
+    async def search_samples(
+        self,
+        query: str = "",
+        key: str = "",
+        chord_type: str = "",
+        bpm_min: int = 0,
+        bpm_max: int = 0,
+        tags: Optional[list[str]] = None,
+        genre: str = "",
+        sample_type: str = "",
+        sort: str = "",
+        per_page: int = 20,
+        page: int = 1,
+        purchased_only: bool = False,
+    ) -> SpliceSearchResult:
+        """Search Splice catalog. Returns ranked results with full metadata."""
+        if not self.connected:
+            return SpliceSearchResult()
+
+        pb2 = self._pb2
+        try:
+            # Build search request
+            purchased = 0  # All
+            if purchased_only:
+                purchased = 1  # OnlyPurchased
+
+            request = pb2.SearchSampleRequest(
+                SearchTerm=query,
+                Key=key.lower() if key else "",
+                ChordType=chord_type,
+                BPMMin=bpm_min,
+                BPMMax=bpm_max,
+                Tags=tags or [],
+                Genre=genre,
+                SampleType=sample_type,
+                SortFn=sort,
+                PerPage=per_page,
+                Page=page,
+                Purchased=purchased,
+            )
+            response = await self.stub.SearchSamples(request)
+            return self._parse_search_response(response)
+        except Exception as exc:
+            logger.warning(f"Splice search failed: {exc}")
+            return SpliceSearchResult()
+
+    def _parse_search_response(self, response) -> SpliceSearchResult:
+        """Convert protobuf SearchSampleResponse to our models."""
+        samples = []
+        for s in response.Samples:
+            samples.append(SpliceSample(
+                file_hash=s.FileHash,
+                filename=s.Filename,
+                local_path=s.LocalPath,
+                audio_key=s.AudioKey,
+                chord_type=s.ChordType,
+                bpm=s.BPM,
+                duration_ms=s.Duration,
+                genre=s.Genre,
+                sample_type=s.SampleType,
+                tags=list(s.Tags),
+                provider_name=s.ProviderName,
+                pack_uuid=s.PackUUID,
+                popularity=s.Popularity,
+                is_premium=s.IsPremium,
+                preview_url=s.PreviewURL,
+                waveform_url=s.WaveformURL,
+                is_downloaded=bool(s.LocalPath),
+            ))
+        return SpliceSearchResult(
+            total_hits=response.TotalHits,
+            samples=samples,
+            matching_tags=dict(response.MatchingTags),
+        )
+
+    # ── Download ────────────────────────────────────────────────────
+
+    async def download_sample(
+        self, file_hash: str, timeout: float = 30.0,
+    ) -> Optional[str]:
+        """Download a sample by file_hash. Returns local path when complete.
+
+        Costs 1 credit. Checks credit floor before downloading.
+        Returns None on failure.
+        """
+        if not self.connected:
+            return None
+
+        pb2 = self._pb2
+        try:
+            # Trigger download
+            await self.stub.DownloadSample(
+                pb2.DownloadSampleRequest(FileHash=file_hash)
+            )
+            # Wait for file to appear on disk
+            return await self._wait_for_download(file_hash, timeout)
+        except Exception as exc:
+            logger.warning(f"Splice download failed for {file_hash}: {exc}")
+            return None
+
+    async def _wait_for_download(
+        self, file_hash: str, timeout: float,
+    ) -> Optional[str]:
+        """Poll SampleInfo until LocalPath is populated."""
+        pb2 = self._pb2
+        deadline = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < deadline:
+            try:
+                response = await self.stub.SampleInfo(
+                    pb2.SampleInfoRequest(FileHash=file_hash)
+                )
+                if response.Sample.LocalPath:
+                    return response.Sample.LocalPath
+            except Exception:
+                pass
+            await asyncio.sleep(0.5)
+        logger.warning(f"Download timed out for {file_hash}")
+        return None
+
+    # ── Sample Info ─────────────────────────────────────────────────
+
+    async def get_sample_info(self, file_hash: str) -> Optional[SpliceSample]:
+        """Get metadata for a specific sample."""
+        if not self.connected:
+            return None
+
+        pb2 = self._pb2
+        try:
+            response = await self.stub.SampleInfo(
+                pb2.SampleInfoRequest(FileHash=file_hash)
+            )
+            s = response.Sample
+            return SpliceSample(
+                file_hash=s.FileHash,
+                filename=s.Filename,
+                local_path=s.LocalPath,
+                audio_key=s.AudioKey,
+                chord_type=s.ChordType,
+                bpm=s.BPM,
+                duration_ms=s.Duration,
+                genre=s.Genre,
+                sample_type=s.SampleType,
+                tags=list(s.Tags),
+                provider_name=s.ProviderName,
+                pack_uuid=s.PackUUID,
+                is_downloaded=bool(s.LocalPath),
+            )
+        except Exception as exc:
+            logger.warning(f"SampleInfo failed: {exc}")
+            return None
+
+    # ── Credits ─────────────────────────────────────────────────────
+
+    async def get_credits(self) -> SpliceCredits:
+        """Get current credit balance and user info."""
+        if not self.connected:
+            return SpliceCredits()
+
+        pb2 = self._pb2
+        try:
+            response = await self.stub.ValidateLogin(
+                pb2.ValidateLoginRequest()
+            )
+            return SpliceCredits(
+                credits=response.User.Credits,
+                username=response.User.Username,
+                plan=response.User.SoundsStatus,
+            )
+        except Exception as exc:
+            logger.warning(f"Credit check failed: {exc}")
+            return SpliceCredits()
+
+    async def can_afford(self, credits_needed: int, budget: int) -> tuple[bool, int]:
+        """Check if we can afford credits_needed within budget.
+
+        Returns (can_afford, credits_remaining).
+        """
+        info = await self.get_credits()
+        remaining = info.credits
+        can = (
+            remaining > CREDIT_HARD_FLOOR
+            and credits_needed <= budget
+            and credits_needed <= (remaining - CREDIT_HARD_FLOOR)
+        )
+        return can, remaining
+
+    # ── Sync ────────────────────────────────────────────────────────
+
+    async def sync_sounds(self) -> bool:
+        """Trigger a full Splice library sync."""
+        if not self.connected:
+            return False
+        pb2 = self._pb2
+        try:
+            await self.stub.SyncSounds(pb2.SyncSoundsRequest())
+            return True
+        except Exception:
+            return False
+
+    # ── Connection Helpers ──────────────────────────────────────────
+
+    def _read_port(self) -> Optional[int]:
+        """Read Splice's current gRPC port from port.conf."""
+        port_file = os.path.join(_SPLICE_APP_SUPPORT, "port.conf")
+        if not os.path.isfile(port_file):
+            return None
+        try:
+            with open(port_file) as f:
+                content = f.read().strip()
+            # Format: "127.0.0.1:56765" or just "56765"
+            if ":" in content:
+                return int(content.split(":")[-1])
+            return int(content)
+        except (ValueError, OSError):
+            return None
+
+    def _read_cert(self) -> Optional[bytes]:
+        """Read Splice's self-signed TLS certificate."""
+        # Search in user-specific directories
+        patterns = [
+            os.path.join(_SPLICE_APP_SUPPORT, ".certs", "cert.pem"),
+            os.path.join(_SPLICE_APP_SUPPORT, "certs", "cert.pem"),
+        ]
+        # Also try user-specific paths
+        user_patterns = glob.glob(
+            os.path.join(_SPLICE_APP_SUPPORT, "users", "*", ".certs", "cert.pem")
+        )
+        patterns.extend(user_patterns)
+
+        for path in patterns:
+            if os.path.isfile(path):
+                try:
+                    with open(path, "rb") as f:
+                        return f.read()
+                except OSError:
+                    continue
+        return None

package/mcp_server/splice_client/models.py

@@ -0,0 +1,96 @@
+"""Splice client data models — Python representations of Splice gRPC messages."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class SpliceSample:
+    """A sample from the Splice catalog or local library."""
+
+    file_hash: str = ""
+    filename: str = ""
+    local_path: str = ""          # empty if not downloaded
+    audio_key: str = ""           # lowercase: "c#", "a", "eb"
+    chord_type: str = ""          # "major", "minor", ""
+    bpm: int = 0
+    duration_ms: int = 0
+    genre: str = ""
+    sample_type: str = ""         # "loop" or "oneshot"
+    tags: list[str] = field(default_factory=list)
+    provider_name: str = ""
+    pack_uuid: str = ""
+    popularity: int = 0
+    is_premium: bool = False
+    preview_url: str = ""
+    waveform_url: str = ""
+    is_downloaded: bool = False
+
+    @property
+    def key_display(self) -> str:
+        """Normalized key: 'c#' + 'minor' → 'C#m'."""
+        if not self.audio_key:
+            return ""
+        key = self.audio_key[0].upper() + self.audio_key[1:]
+        if self.chord_type.lower() in ("minor", "min"):
+            key += "m"
+        return key
+
+    @property
+    def duration_seconds(self) -> float:
+        return self.duration_ms / 1000.0 if self.duration_ms else 0.0
+
+    def to_dict(self) -> dict:
+        return {
+            "file_hash": self.file_hash,
+            "filename": self.filename,
+            "local_path": self.local_path,
+            "key": self.key_display,
+            "audio_key_raw": self.audio_key,
+            "chord_type": self.chord_type,
+            "bpm": self.bpm,
+            "duration": self.duration_seconds,
+            "genre": self.genre,
+            "sample_type": self.sample_type,
+            "tags": self.tags,
+            "provider": self.provider_name,
+            "pack_uuid": self.pack_uuid,
+            "popularity": self.popularity,
+            "is_downloaded": self.is_downloaded,
+            "is_premium": self.is_premium,
+        }
+
+
+@dataclass
+class SpliceSearchResult:
+    """Result from a Splice catalog search."""
+
+    total_hits: int = 0
+    samples: list[SpliceSample] = field(default_factory=list)
+    matching_tags: dict[str, int] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return {
+            "total_hits": self.total_hits,
+            "sample_count": len(self.samples),
+            "samples": [s.to_dict() for s in self.samples],
+            "matching_tags": self.matching_tags,
+        }
+
+
+@dataclass
+class SpliceCredits:
+    """User credit status."""
+
+    credits: int = 0
+    username: str = ""
+    plan: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "credits": self.credits,
+            "username": self.username,
+            "plan": self.plan,
+        }

package/mcp_server/splice_client/protos/__init__.py

@@ -0,0 +1 @@
+"""Generated protobuf stubs for Splice gRPC API."""