livepilot 1.9.23 → 1.10.0

package/mcp_server/semantic_moves/sound_design_moves.py

@@ -14,12 +14,12 @@ ADD_WARMTH = SemanticMove(
     protect={"clarity": 0.6, "punch": 0.5},
     risk_level="low",
     compile_plan=[
-        {"tool": "set_device_parameter", "params": {"description": "Add Saturator drive +2-4dB for harmonic warmth"}, "description": "Add saturation"},
-        {"tool": "set_device_parameter", "params": {"description": "Boost EQ low-mid shelf +1-2dB"}, "description": "Low-mid warmth"},
+        {"tool": "set_device_parameter", "params": {"description": "Add Saturator drive +2-4dB for harmonic warmth"}, "description": "Add saturation", "backend": "remote_command"},
+        {"tool": "set_device_parameter", "params": {"description": "Boost EQ low-mid shelf +1-2dB"}, "description": "Low-mid warmth", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_master_spectrum", "check": "low-mid energy increased, high-mid stable"},
-        {"tool": "get_track_meters", "check": "target track producing audio"},
+        {"tool": "get_master_spectrum", "check": "low-mid energy increased, high-mid stable", "backend": "mcp_tool"},
+        {"tool": "get_track_meters", "check": "target track producing audio", "backend": "remote_command"},
     ],
 )
 
@@ -31,11 +31,11 @@ ADD_TEXTURE = SemanticMove(
     protect={"clarity": 0.6},
     risk_level="medium",
     compile_plan=[
-        {"tool": "apply_automation_shape", "params": {"curve_type": "perlin", "description": "Perlin noise on filter cutoff for organic texture"}, "description": "Organic filter motion"},
-        {"tool": "set_track_send", "params": {"description": "Increase delay send for spatial texture"}, "description": "Spatial texture via delay"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "perlin", "description": "Perlin noise on filter cutoff for organic texture"}, "description": "Organic filter motion", "backend": "mcp_tool"},
+        {"tool": "set_track_send", "params": {"description": "Increase delay send for spatial texture"}, "description": "Spatial texture via delay", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "track producing audio with variation"},
+        {"tool": "get_track_meters", "check": "track producing audio with variation", "backend": "remote_command"},
     ],
 )
 
@@ -47,11 +47,11 @@ SHAPE_TRANSIENTS = SemanticMove(
     protect={"warmth": 0.5},
     risk_level="low",
     compile_plan=[
-        {"tool": "set_device_parameter", "params": {"description": "Adjust Compressor attack time (faster = sharper transients, slower = rounder)"}, "description": "Shape attack"},
-        {"tool": "set_device_parameter", "params": {"description": "Adjust Compressor release for rhythmic pumping"}, "description": "Shape release"},
+        {"tool": "set_device_parameter", "params": {"description": "Adjust Compressor attack time (faster = sharper transients, slower = rounder)"}, "description": "Shape attack", "backend": "remote_command"},
+        {"tool": "set_device_parameter", "params": {"description": "Adjust Compressor release for rhythmic pumping"}, "description": "Shape release", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "track producing audio with expected transient character"},
+        {"tool": "get_track_meters", "check": "track producing audio with expected transient character", "backend": "remote_command"},
     ],
 )
 
@@ -63,13 +63,13 @@ ADD_SPACE = SemanticMove(
     protect={"punch": 0.6, "clarity": 0.5},
     risk_level="low",
     compile_plan=[
-        {"tool": "set_track_send", "params": {"description": "Increase reverb send to 25-35%"}, "description": "Add reverb depth"},
-        {"tool": "set_track_send", "params": {"description": "Add subtle delay send 10-15%"}, "description": "Add delay texture"},
-        {"tool": "set_track_pan", "params": {"description": "Widen pan slightly for spatial presence"}, "description": "Widen spatial field"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb send to 25-35%"}, "description": "Add reverb depth", "backend": "remote_command"},
+        {"tool": "set_track_send", "params": {"description": "Add subtle delay send 10-15%"}, "description": "Add delay texture", "backend": "remote_command"},
+        {"tool": "set_track_pan", "params": {"description": "Widen pan slightly for spatial presence"}, "description": "Widen spatial field", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "stereo output present, no phase cancellation"},
-        {"tool": "analyze_mix", "check": "stereo.mono_risk is false"},
+        {"tool": "get_track_meters", "check": "stereo output present, no phase cancellation", "backend": "remote_command"},
+        {"tool": "analyze_mix", "check": "stereo.mono_risk is false", "backend": "mcp_tool"},
     ],
 )
 

package/mcp_server/semantic_moves/tools.py

@@ -177,24 +177,25 @@ def apply_semantic_move(
         result["note"] = "Awaiting approval — present the plan to the user, then execute steps individually"
         return result
 
-    # explore mode — execute immediately
+    # explore mode — execute through unified router
+    from ..runtime.execution_router import execute_plan_steps
+
+    step_dicts = [
+        {"tool": step.tool, "params": step.params, "description": step.description}
+        for step in plan.steps
+    ]
+    exec_results = execute_plan_steps(step_dicts, ableton=ableton, ctx=ctx)
+
     executed_steps = []
-    for step in plan.steps:
-        try:
-            tool_result = ableton.send_command(step.tool, step.params)
-            executed_steps.append({
-                "tool": step.tool,
-                "description": step.description,
-                "result": tool_result,
-                "ok": True,
-            })
-        except Exception as exc:
-            executed_steps.append({
-                "tool": step.tool,
-                "description": step.description,
-                "error": str(exc),
-                "ok": False,
-            })
+    for i, er in enumerate(exec_results):
+        executed_steps.append({
+            "tool": er.tool,
+            "backend": er.backend,
+            "description": step_dicts[i].get("description", ""),
+            "result": er.result if er.ok else None,
+            "error": er.error if not er.ok else None,
+            "ok": er.ok,
+        })
 
     result = plan.to_dict()
     result["executed"] = True

package/mcp_server/semantic_moves/transition_moves.py

@@ -11,12 +11,12 @@ INCREASE_FORWARD_MOTION = SemanticMove(
     protect={"clarity": 0.6},
     risk_level="low",
     compile_plan=[
-        {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising filter cutoff over 4 bars"}, "description": "Rising filter sweep"},
-        {"tool": "set_track_volume", "params": {"description": "Push rhythm elements +5-8%"}, "description": "Push rhythm forward"},
-        {"tool": "apply_automation_shape", "params": {"curve_type": "linear", "description": "Rising reverb send for anticipation"}, "description": "Build reverb wash"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising filter cutoff over 4 bars"}, "description": "Rising filter sweep", "backend": "mcp_tool"},
+        {"tool": "set_track_volume", "params": {"description": "Push rhythm elements +5-8%"}, "description": "Push rhythm forward", "backend": "remote_command"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "linear", "description": "Rising reverb send for anticipation"}, "description": "Build reverb wash", "backend": "mcp_tool"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "energy increasing, all tracks alive"},
+        {"tool": "get_track_meters", "check": "energy increasing, all tracks alive", "backend": "remote_command"},
     ],
 )
 
@@ -28,13 +28,13 @@ OPEN_CHORUS = SemanticMove(
     protect={"clarity": 0.6, "cohesion": 0.5},
     risk_level="medium",
     compile_plan=[
-        {"tool": "set_track_volume", "params": {"description": "Push all melodic tracks +10-15%"}, "description": "Push chorus energy"},
-        {"tool": "set_track_pan", "params": {"description": "Widen stereo field on chords/pads"}, "description": "Widen stereo"},
-        {"tool": "set_track_send", "params": {"description": "Increase reverb/delay sends for spaciousness"}, "description": "Add space"},
+        {"tool": "set_track_volume", "params": {"description": "Push all melodic tracks +10-15%"}, "description": "Push chorus energy", "backend": "remote_command"},
+        {"tool": "set_track_pan", "params": {"description": "Widen stereo field on chords/pads"}, "description": "Widen stereo", "backend": "remote_command"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb/delay sends for spaciousness"}, "description": "Add space", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "overall energy increased, stereo field wider"},
-        {"tool": "analyze_mix", "check": "no clipping, stereo.mono_risk is false"},
+        {"tool": "get_track_meters", "check": "overall energy increased, stereo field wider", "backend": "remote_command"},
+        {"tool": "analyze_mix", "check": "no clipping, stereo.mono_risk is false", "backend": "mcp_tool"},
     ],
 )
 
@@ -46,12 +46,12 @@ CREATE_BREAKDOWN = SemanticMove(
     protect={"cohesion": 0.5},
     risk_level="medium",
     compile_plan=[
-        {"tool": "set_track_volume", "params": {"description": "Pull drums to 20-30%"}, "description": "Strip drums"},
-        {"tool": "set_track_volume", "params": {"description": "Pull bass to 30-40%"}, "description": "Reduce bass"},
-        {"tool": "set_track_send", "params": {"description": "Increase reverb send on remaining elements"}, "description": "Add reverb depth"},
+        {"tool": "set_track_volume", "params": {"description": "Pull drums to 20-30%"}, "description": "Strip drums", "backend": "remote_command"},
+        {"tool": "set_track_volume", "params": {"description": "Pull bass to 30-40%"}, "description": "Reduce bass", "backend": "remote_command"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb send on remaining elements"}, "description": "Add reverb depth", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "energy significantly reduced, at least one element still prominent"},
+        {"tool": "get_track_meters", "check": "energy significantly reduced, at least one element still prominent", "backend": "remote_command"},
     ],
 )
 
@@ -63,11 +63,11 @@ BRIDGE_SECTIONS = SemanticMove(
     protect={"clarity": 0.6},
     risk_level="low",
     compile_plan=[
-        {"tool": "apply_automation_shape", "params": {"curve_type": "cosine", "description": "Gentle filter sweep across bridge"}, "description": "Bridge filter motion"},
-        {"tool": "set_track_volume", "params": {"description": "Gentle volume crossfade between section elements"}, "description": "Crossfade elements"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "cosine", "description": "Gentle filter sweep across bridge"}, "description": "Bridge filter motion", "backend": "mcp_tool"},
+        {"tool": "set_track_volume", "params": {"description": "Gentle volume crossfade between section elements"}, "description": "Crossfade elements", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "smooth level transition, no dropouts"},
+        {"tool": "get_track_meters", "check": "smooth level transition, no dropouts", "backend": "remote_command"},
     ],
 )
 

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/services/__init__.py

@@ -0,0 +1 @@
+"""Shared services consumed by multiple domains."""

package/mcp_server/services/motif_service.py

@@ -0,0 +1,67 @@
+"""Shared motif service — one entry point for all motif consumers.
+
+SongBrain, HookHunter, and musical_intelligence all import from here
+instead of making ad-hoc calls to the motif engine or TCP.
+
+Pure computation — no I/O. Callers provide pre-fetched data.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+def get_motif_data(
+    notes_by_track: dict[int, list[dict]],
+) -> dict:
+    """Extract motif data from pre-fetched notes.
+
+    Args:
+        notes_by_track: {track_index: [note_dicts]} from get_notes calls
+
+    Returns:
+        Motif analysis dict with motifs, motif_count, tracks_analyzed.
+        Returns empty result if no notes or engine unavailable.
+    """
+    if not notes_by_track:
+        return {"motifs": [], "motif_count": 0, "tracks_analyzed": 0}
+
+    try:
+        from ..tools import _motif_engine as motif_engine
+        motifs = motif_engine.detect_motifs(notes_by_track)
+        return {
+            "motifs": [m.to_dict() for m in motifs],
+            "motif_count": len(motifs),
+            "tracks_analyzed": len(notes_by_track),
+        }
+    except Exception:
+        return {"motifs": [], "motif_count": 0, "tracks_analyzed": 0}
+
+
+def fetch_notes_from_ableton(ableton, tracks: list[dict], max_clips: int = 8) -> dict[int, list[dict]]:
+    """Fetch notes from Ableton for motif analysis.
+
+    This is the I/O helper — calls get_notes through valid TCP commands.
+    Callers pass the ableton connection; this function does the fetching.
+    """
+    notes_by_track: dict[int, list[dict]] = {}
+    for track in tracks:
+        t_idx = track.get("index", 0)
+        if not track.get("has_midi_input", False) and not any(
+            kw in track.get("name", "").lower()
+            for kw in ("midi", "synth", "bass", "lead", "pad", "keys", "piano", "chord")
+        ):
+            continue
+        track_notes = []
+        for clip_idx in range(max_clips):
+            try:
+                result = ableton.send_command("get_notes", {
+                    "track_index": t_idx,
+                    "clip_index": clip_idx,
+                })
+                track_notes.extend(result.get("notes", []))
+            except Exception:
+                pass
+        if track_notes:
+            notes_by_track[t_idx] = track_notes
+    return notes_by_track

package/mcp_server/session_continuity/tracker.py

@@ -23,14 +23,22 @@ from .models import (
 _story = SessionStory()
 _threads: dict[str, CreativeThread] = {}
 _turns: list[TurnResolution] = []
+_project_store = None  # Optional PersistentProjectStore
+
+
+def set_project_store(store) -> None:
+    """Attach a persistent project store for flush-on-write."""
+    global _project_store
+    _project_store = store
 
 
 def reset_story() -> None:
     """Reset session story (for testing)."""
-    global _story, _threads, _turns
+    global _story, _threads, _turns, _project_store
     _story = SessionStory()
     _threads = {}
     _turns = []
+    _project_store = None
 
 
 # ── Session story ─────────────────────────────────────────────────
@@ -117,6 +125,13 @@ def record_turn_resolution(
     else:
         _story.mood_arc.append("neutral")
 
+    # Flush to persistent store
+    if _project_store is not None:
+        try:
+            _project_store.save_turn(turn.to_dict())
+        except Exception:
+            pass
+
     return turn
 
 
@@ -138,6 +153,14 @@ def open_thread(description: str, domain: str = "", priority: float = 0.5) -> Cr
         last_touched_ms=now,
     )
     _threads[thread_id] = thread
+
+    # Flush to persistent store
+    if _project_store is not None:
+        try:
+            _project_store.save_thread(thread.to_dict())
+        except Exception:
+            pass
+
     return thread
 
 
@@ -147,6 +170,11 @@ def resolve_thread(thread_id: str) -> Optional[CreativeThread]:
     if thread:
         thread.status = "resolved"
         thread.last_touched_ms = int(time.time() * 1000)
+        if _project_store is not None:
+            try:
+                _project_store.save_thread(thread.to_dict())
+            except Exception:
+                pass
     return thread
 
 

package/mcp_server/song_brain/builder.py

@@ -74,16 +74,43 @@ def build_song_brain(
 
     drift_risk = _estimate_drift_risk(recent_moves, sacred)
 
+    # Evidence-weighted confidence adjustment
+    # Weights: motif=0.4, composition=0.2, role_graph=0.15, scenes=0.15, recent_moves=0.1
+    evidence_weights = {
+        "motif_data": 0.4,
+        "composition_analysis": 0.2,
+        "role_graph": 0.15,
+        "scenes": 0.15,
+        "recent_moves": 0.1,
+    }
+    evidence_score = sum(
+        weight for source, weight in evidence_weights.items()
+        if built_from.get(source, False)
+    )
+    # Adjust identity confidence by evidence availability
+    adjusted_confidence = round(identity_confidence * (0.4 + 0.6 * evidence_score), 3)
+
+    evidence_breakdown = {
+        "raw_confidence": identity_confidence,
+        "evidence_score": round(evidence_score, 3),
+        "adjusted_confidence": adjusted_confidence,
+        "sources": {
+            source: {"available": built_from.get(source, False), "weight": weight}
+            for source, weight in evidence_weights.items()
+        },
+    }
+
     return SongBrain(
         brain_id=brain_id,
         identity_core=identity_core,
-        identity_confidence=identity_confidence,
+        identity_confidence=adjusted_confidence,
         sacred_elements=sacred,
         section_purposes=sections,
         energy_arc=energy_arc,
         identity_drift_risk=drift_risk,
         payoff_targets=payoff_targets,
         open_questions=open_questions,
+        evidence_breakdown=evidence_breakdown,
         built_from=built_from,
     )
 

package/mcp_server/song_brain/models.py

@@ -84,6 +84,9 @@ class SongBrain:
     # Open questions the song has not resolved
     open_questions: list[OpenQuestion] = field(default_factory=list)
 
+    # Evidence breakdown — what data informed each inference
+    evidence_breakdown: dict = field(default_factory=dict)
+
     # Metadata
     built_from: dict = field(default_factory=dict)  # what data sources contributed
 
@@ -98,6 +101,7 @@ class SongBrain:
             "identity_drift_risk": self.identity_drift_risk,
             "payoff_targets": self.payoff_targets,
             "open_questions": [q.to_dict() for q in self.open_questions],
+            "evidence_breakdown": self.evidence_breakdown,
             "built_from": self.built_from,
         }
 

package/mcp_server/song_brain/tools.py

@@ -88,9 +88,11 @@ def _fetch_session_data(ctx: Context) -> dict:
     except Exception:
         pass
 
-    # Motif data — from the motif engine if notes exist
+    # Motif data — via shared motif service (pure-Python, not TCP)
     try:
-        data["motif_data"] = ableton.send_command("get_motif_graph")
+        from ..services.motif_service import get_motif_data, fetch_notes_from_ableton
+        notes_by_track = fetch_notes_from_ableton(ableton, data.get("tracks", []))
+        data["motif_data"] = get_motif_data(notes_by_track)
     except Exception:
         pass  # Motif graph requires notes in clips; empty is valid
 
@@ -147,6 +149,21 @@ def build_song_brain(ctx: Context) -> dict:
     Returns the full SongBrain as a dict.
     """
     data = _fetch_session_data(ctx)
+
+    # Capability reporting — what data was actually available
+    from ..runtime.capability import build_capability
+    cap = build_capability(
+        required=["session_info", "scenes", "tracks", "motif_data", "composition_analysis", "role_graph"],
+        available={
+            "session_info": bool(data.get("session_info", {}).get("tempo")),
+            "scenes": bool(data.get("scenes")),
+            "tracks": bool(data.get("tracks")),
+            "motif_data": bool(data.get("motif_data")),
+            "composition_analysis": bool(data.get("composition_analysis")),
+            "role_graph": bool(data.get("role_graph")),
+        },
+    )
+
     brain = builder.build_song_brain(
         session_info=data["session_info"],
         scenes=data["scenes"],
@@ -161,6 +178,7 @@ def build_song_brain(ctx: Context) -> dict:
     return {
         **brain.to_dict(),
         "summary": brain.summary,
+        "capability": cap.to_dict(),
     }
 
 

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."""