livepilot 1.9.24 → 1.10.0

package/mcp_server/semantic_moves/sample_compilers.py

@@ -0,0 +1,372 @@
+"""Compilers for sample-domain semantic moves.
+
+These compile sample manipulation intents into concrete tool call sequences
+using the session kernel to find appropriate tracks and devices.
+"""
+
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_compiler
+from .models import SemanticMove
+from . import resolvers
+
+
+def _compile_sample_chop_rhythm(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_chop_rhythm': load, slice, and chop a sample for rhythm."""
+    steps = []
+    descriptions = []
+    warnings = []
+
+    # Find drum/percussion tracks to layer alongside
+    drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+
+    # Create a new track for the chopped sample
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Chop"},
+        description="Create track for chopped sample",
+    ))
+    descriptions.append("Create chop track")
+
+    # Load into Simpler — track index will be last + 1
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx},
+        description="Load sample into Simpler for slicing",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_simpler_playback_mode",
+        params={"track_index": new_idx, "mode": "slice"},
+        description="Switch to slice mode for rhythmic chopping",
+    ))
+    descriptions.append("Slice sample")
+
+    # Balance against existing drums
+    if drums:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": new_idx, "volume": 0.55},
+            description="Set chop volume below main drums",
+        ))
+    else:
+        warnings.append("No drum tracks found — chop will be the primary rhythm")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify chopped sample producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "Chop sample for rhythm",
+        requires_approval=True,
+        warnings=warnings,
+    )
+
+
+def _compile_sample_texture_layer(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_texture_layer': load and filter a sample as background texture."""
+    steps = []
+    descriptions = []
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Texture"},
+        description="Create track for texture layer",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx},
+        description="Load textural sample into Simpler",
+    ))
+    descriptions.append("Load texture sample")
+
+    # Low volume for background placement
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.35},
+        description="Set texture low in mix for background presence",
+    ))
+    descriptions.append("Set background level")
+
+    # Add reverb send for spatial depth
+    steps.append(CompiledStep(
+        tool="set_track_send",
+        params={"track_index": new_idx, "send_index": 0, "value": 0.40},
+        description="Heavy reverb for spatial depth on texture",
+    ))
+    descriptions.append("Add reverb depth")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify texture layer producing audio at low level",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+def _compile_sample_vocal_ghost(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_vocal_ghost': reverse, pitch, and wash a vocal sample."""
+    steps = []
+    descriptions = []
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Ghost Vox"},
+        description="Create track for ghost vocal",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx},
+        description="Load vocal sample into Simpler",
+    ))
+
+    steps.append(CompiledStep(
+        tool="reverse_simpler",
+        params={"track_index": new_idx},
+        description="Reverse vocal for ghostly character",
+    ))
+    descriptions.append("Reverse vocal")
+
+    # Heavy reverb wash
+    steps.append(CompiledStep(
+        tool="set_track_send",
+        params={"track_index": new_idx, "send_index": 0, "value": 0.55},
+        description="Heavy reverb wash for ghostly depth",
+    ))
+    descriptions.append("Reverb wash")
+
+    # Low volume — ghosts live in the background
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.30},
+        description="Set ghost vocal low in mix",
+    ))
+    descriptions.append("Background level")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify ghost vocal producing audio with reverb tail",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions),
+        requires_approval=True,
+    )
+
+
+def _compile_sample_break_layer(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_break_layer': slice a break and layer over existing drums."""
+    steps = []
+    descriptions = []
+    warnings = []
+
+    drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    if not drums:
+        warnings.append("No existing drum tracks — break will be the primary rhythm")
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Break"},
+        description="Create track for breakbeat layer",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx},
+        description="Load breakbeat into Simpler",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_simpler_playback_mode",
+        params={"track_index": new_idx, "mode": "slice"},
+        description="Slice break by transients for individual hits",
+    ))
+    descriptions.append("Slice break")
+
+    # Sit below main drums
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.45},
+        description="Set break layer below main drums",
+    ))
+    descriptions.append("Balance break level")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify break layer producing audio alongside drums",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "Layer breakbeat",
+        requires_approval=True,
+        warnings=warnings,
+    )
+
+
+def _compile_sample_resample_destroy(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_resample_destroy': warp and mangle a sample destructively.
+
+    SAFETY: This is a high-risk move — always requires approval.
+    Only adjusts device params when a known device is confirmed present.
+    """
+    steps = []
+    descriptions = []
+    warnings = ["High-risk: destructive processing — consider duplicating track first"]
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Destroy"},
+        description="Create track for destructive resampling",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx},
+        description="Load sample for destruction",
+    ))
+    descriptions.append("Load source")
+
+    steps.append(CompiledStep(
+        tool="warp_simpler",
+        params={"track_index": new_idx},
+        description="Apply extreme warp for time-stretch artifacts",
+    ))
+    descriptions.append("Warp for artifacts")
+
+    # Use volume + send instead of blindly setting device params
+    steps.append(CompiledStep(
+        tool="set_track_send",
+        params={"track_index": new_idx, "send_index": 0, "value": 0.30},
+        description="Add reverb send for destroyed texture depth",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.50},
+        description="Set destroyed sample at moderate level",
+    ))
+    descriptions.append("Set level")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify destroyed sample producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="high",
+        summary="; ".join(descriptions),
+        requires_approval=True,
+        warnings=warnings,
+    )
+
+
+def _compile_sample_one_shot_accent(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'sample_one_shot_accent': load a one-shot for rhythmic punctuation."""
+    steps = []
+    descriptions = []
+
+    tracks = kernel.get("session_info", {}).get("tracks", [])
+    new_idx = len(tracks)
+
+    steps.append(CompiledStep(
+        tool="create_midi_track",
+        params={"name": "Accent"},
+        description="Create track for one-shot accent",
+    ))
+
+    steps.append(CompiledStep(
+        tool="load_sample_to_simpler",
+        params={"track_index": new_idx},
+        description="Load one-shot into Simpler",
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_simpler_playback_mode",
+        params={"track_index": new_idx, "mode": "one_shot"},
+        description="One-shot mode for trigger playback",
+    ))
+    descriptions.append("One-shot mode")
+
+    steps.append(CompiledStep(
+        tool="crop_simpler",
+        params={"track_index": new_idx},
+        description="Tight crop around the transient",
+    ))
+    descriptions.append("Crop to transient")
+
+    # Accent should be punchy but not dominating
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": new_idx, "volume": 0.60},
+        description="Set accent at punchy but balanced level",
+    ))
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify one-shot accent triggers cleanly",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "One-shot accent",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+# ── Register ────────────────────────────────────────────────────────────────
+
+register_compiler("sample_chop_rhythm", _compile_sample_chop_rhythm)
+register_compiler("sample_texture_layer", _compile_sample_texture_layer)
+register_compiler("sample_vocal_ghost", _compile_sample_vocal_ghost)
+register_compiler("sample_break_layer", _compile_sample_break_layer)
+register_compiler("sample_resample_destroy", _compile_sample_resample_destroy)
+register_compiler("sample_one_shot_accent", _compile_sample_one_shot_accent)

package/mcp_server/server.py

@@ -40,6 +40,40 @@ 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."""
@@ -80,6 +114,8 @@ async def lifespan(server):
     }
 
     try:
+        if bridge_state["transport"] is not None:
+            await _warm_analyzer_bridge(ableton, spectral)
         yield {
             "ableton": ableton,
             "spectral": spectral,
@@ -140,6 +176,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 +210,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 +250,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/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."""