livepilot 1.9.22 → 1.9.24

package/mcp_server/semantic_moves/transition_compilers.py

@@ -0,0 +1,222 @@
+"""Compilers for transition-domain semantic moves."""
+
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_compiler
+from .models import SemanticMove
+from . import resolvers
+
+
+def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'increase_forward_motion': rising filter + rhythm push."""
+    steps = []
+    descriptions = []
+
+    melodic = resolvers.find_tracks_by_role(kernel, ["chords", "lead", "pad"])
+    drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+
+    for mt in melodic[:1]:
+        steps.append(CompiledStep(
+            tool="apply_automation_shape",
+            params={
+                "track_index": mt["index"],
+                "clip_index": 0,
+                "parameter_type": "device",
+                "device_index": 0,
+                "parameter_index": 0,
+                "curve_type": "exponential",
+                "start": 0.2,
+                "end": 0.7,
+                "duration": 4,
+            },
+            description=f"Rising filter sweep on {mt['name']} over 4 bars",
+        ))
+        descriptions.append(f"Rising filter on {mt['name']}")
+
+    for dt in drums[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": dt["index"], "volume": 0.75},
+            description=f"Push {dt['name']} to 0.75 for forward drive",
+        ))
+        descriptions.append(f"Push {dt['name']} forward")
+
+    for mt in melodic[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_send",
+            params={"track_index": mt["index"], "send_index": 0, "value": 0.30},
+            description=f"Build reverb wash on {mt['name']}",
+        ))
+        descriptions.append(f"Reverb wash on {mt['name']}")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify forward momentum — energy increasing",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No melodic tracks for motion",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+def _compile_open_chorus(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'open_chorus': maximize width, energy, brightness."""
+    steps = []
+    descriptions = []
+
+    melodic = resolvers.find_tracks_by_role(kernel, ["chords", "lead", "pad"])
+    drums = resolvers.find_tracks_by_role(kernel, ["drums"])
+
+    # Push all melodic tracks
+    for mt in melodic:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": mt["index"], "volume": 0.75},
+            description=f"Push {mt['name']} to 0.75 for chorus energy",
+        ))
+        descriptions.append(f"Push {mt['name']}")
+
+    # Widen chords
+    for ct in resolvers.find_tracks_by_role(kernel, ["chords"])[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_pan",
+            params={"track_index": ct["index"], "pan": -0.30},
+            description=f"Pan {ct['name']} left for width",
+        ))
+
+    for lt in resolvers.find_tracks_by_role(kernel, ["lead"])[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_pan",
+            params={"track_index": lt["index"], "pan": 0.25},
+            description=f"Pan {lt['name']} right for width",
+        ))
+
+    # Increase sends for spaciousness
+    for mt in melodic[:2]:
+        steps.append(CompiledStep(
+            tool="set_track_send",
+            params={"track_index": mt["index"], "send_index": 0, "value": 0.30},
+            description=f"Add reverb space to {mt['name']}",
+        ))
+
+    descriptions.append("Widen stereo + add space")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify chorus energy — all tracks at high level",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "No tracks for chorus",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+def _compile_create_breakdown(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'create_breakdown': strip to minimal elements."""
+    steps = []
+    descriptions = []
+
+    drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    bass = resolvers.find_tracks_by_role(kernel, ["bass"])
+    pads = resolvers.find_tracks_by_role(kernel, ["pad"])
+
+    for dt in drums:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": dt["index"], "volume": 0.25},
+            description=f"Strip {dt['name']} to 0.25 for breakdown",
+        ))
+        descriptions.append(f"Strip {dt['name']}")
+
+    for bt in bass[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": bt["index"], "volume": 0.30},
+            description=f"Reduce {bt['name']} to 0.30",
+        ))
+        descriptions.append(f"Reduce {bt['name']}")
+
+    # Increase reverb on remaining pads for depth
+    for pt in pads[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_send",
+            params={"track_index": pt["index"], "send_index": 0, "value": 0.50},
+            description=f"Deep reverb on {pt['name']} for breakdown atmosphere",
+        ))
+        descriptions.append(f"Deep reverb on {pt['name']}")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify breakdown — energy low, atmosphere present",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "No tracks for breakdown",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+def _compile_bridge_sections(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'bridge_sections': gentle filter motion + volume crossfade."""
+    steps = []
+    descriptions = []
+
+    melodic = resolvers.find_tracks_by_role(kernel, ["chords", "lead", "pad"])
+
+    for mt in melodic[:1]:
+        steps.append(CompiledStep(
+            tool="apply_automation_shape",
+            params={
+                "track_index": mt["index"],
+                "clip_index": 0,
+                "parameter_type": "send",
+                "send_index": 0,
+                "curve_type": "cosine",
+                "center": 0.25,
+                "amplitude": 0.15,
+                "duration": 4,
+                "density": 8,
+            },
+            description=f"Gentle reverb motion on {mt['name']} across bridge",
+        ))
+        descriptions.append(f"Bridge motion on {mt['name']}")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify smooth bridge — no dropouts",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No tracks for bridge",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+# ── Register ────────────────────────────────────────────────────────────────
+
+register_compiler("increase_forward_motion", _compile_increase_forward_motion)
+register_compiler("open_chorus", _compile_open_chorus)
+register_compiler("create_breakdown", _compile_create_breakdown)
+register_compiler("bridge_sections", _compile_bridge_sections)

package/mcp_server/semantic_moves/transition_moves.py

@@ -0,0 +1,76 @@
+"""Transition-domain semantic moves — musical intents for section transitions."""
+
+from .models import SemanticMove
+from .registry import register
+
+INCREASE_FORWARD_MOTION = SemanticMove(
+    move_id="increase_forward_motion",
+    family="transition",
+    intent="Increase forward motion and momentum toward the next section",
+    targets={"motion": 0.5, "energy": 0.3, "tension": 0.2},
+    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", "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", "backend": "remote_command"},
+    ],
+)
+
+OPEN_CHORUS = SemanticMove(
+    move_id="open_chorus",
+    family="transition",
+    intent="Open into a chorus — maximize width, energy, and brightness",
+    targets={"energy": 0.4, "width": 0.3, "contrast": 0.3},
+    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", "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", "backend": "remote_command"},
+        {"tool": "analyze_mix", "check": "no clipping, stereo.mono_risk is false", "backend": "mcp_tool"},
+    ],
+)
+
+CREATE_BREAKDOWN = SemanticMove(
+    move_id="create_breakdown",
+    family="transition",
+    intent="Create a breakdown — strip to minimal elements for contrast before rebuild",
+    targets={"contrast": 0.5, "depth": 0.3, "clarity": 0.2},
+    protect={"cohesion": 0.5},
+    risk_level="medium",
+    compile_plan=[
+        {"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", "backend": "remote_command"},
+    ],
+)
+
+BRIDGE_SECTIONS = SemanticMove(
+    move_id="bridge_sections",
+    family="transition",
+    intent="Bridge between two sections with a transitional passage — filter sweep + density shift",
+    targets={"motion": 0.4, "contrast": 0.3, "cohesion": 0.3},
+    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", "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", "backend": "remote_command"},
+    ],
+)
+
+# Register all transition moves
+for _move in [INCREASE_FORWARD_MOTION, OPEN_CHORUS, CREATE_BREAKDOWN, BRIDGE_SECTIONS]:
+    register(_move)

package/mcp_server/server.py

@@ -130,6 +130,16 @@ from .reference_engine import tools as reference_tools     # noqa: F401, E402
 from .translation_engine import tools as translation_tools  # noqa: F401, E402
 from .performance_engine import tools as performance_tools  # noqa: F401, E402
 from .runtime import safety_tools  # noqa: F401, E402
+from .semantic_moves import tools as semantic_move_tools  # noqa: F401, E402
+from .experiment import tools as experiment_tools         # noqa: F401, E402
+from .musical_intelligence import tools as musical_intel_tools  # noqa: F401, E402
+from .song_brain import tools as song_brain_tools              # noqa: F401, E402
+from .preview_studio import tools as preview_studio_tools      # noqa: F401, E402
+from .hook_hunter import tools as hook_hunter_tools            # noqa: F401, E402
+from .stuckness_detector import tools as stuckness_tools       # noqa: F401, E402
+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
 
 
 # ---------------------------------------------------------------------------

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

@@ -0,0 +1,6 @@
+"""Session Continuity — collaborative memory for Stage 2.
+
+Tracks unresolved creative goals, abandoned directions, what has been
+tried, and what the user loved or rejected. Separates taste (cross-session)
+from identity (in-song) for better ranking.
+"""

package/mcp_server/session_continuity/models.py

@@ -0,0 +1,86 @@
+"""Session Continuity data models — pure dataclasses, zero I/O."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import asdict, dataclass, field
+from typing import Optional
+
+
+@dataclass
+class CreativeThread:
+    """An unresolved creative goal or direction."""
+
+    thread_id: str = ""
+    description: str = ""
+    domain: str = ""  # "arrangement", "sound_design", "mix", "harmony", "identity"
+    status: str = "open"  # "open", "resolved", "abandoned", "stale"
+    priority: float = 0.5
+    created_at_ms: int = 0
+    last_touched_ms: int = 0
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @property
+    def is_stale(self) -> bool:
+        """A thread is stale if untouched for >30 minutes."""
+        now = int(time.time() * 1000)
+        return (now - self.last_touched_ms) > 30 * 60 * 1000 if self.last_touched_ms else False
+
+
+@dataclass
+class TurnResolution:
+    """What happened in a single creative turn."""
+
+    turn_id: str = ""
+    request_text: str = ""
+    outcome: str = ""  # "accepted", "rejected", "modified", "undone"
+    move_applied: str = ""
+    identity_effect: str = ""
+    user_sentiment: str = ""  # "loved", "liked", "neutral", "disliked", "hated"
+    timestamp_ms: int = 0
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class SessionStory:
+    """The narrative of the current session."""
+
+    song_id: str = ""
+    identity_summary: str = ""
+    what_changed_last: str = ""
+    what_still_feels_open: list[str] = field(default_factory=list)
+    threads: list[CreativeThread] = field(default_factory=list)
+    turns: list[TurnResolution] = field(default_factory=list)
+    mood_arc: list[str] = field(default_factory=list)  # sequence of moods
+
+    def to_dict(self) -> dict:
+        return {
+            "song_id": self.song_id,
+            "identity_summary": self.identity_summary,
+            "what_changed_last": self.what_changed_last,
+            "what_still_feels_open": self.what_still_feels_open,
+            "threads": [t.to_dict() for t in self.threads if t.status == "open"],
+            "recent_turns": [t.to_dict() for t in self.turns[-5:]],
+            "mood_arc": self.mood_arc[-10:],
+            "total_turns": len(self.turns),
+        }
+
+
+@dataclass
+class TasteIdentityRanking:
+    """Result of ranking candidates with separated taste and identity."""
+
+    candidate_id: str = ""
+    taste_score: float = 0.0
+    identity_score: float = 0.0
+    composite_score: float = 0.0
+    taste_explanation: str = ""
+    identity_explanation: str = ""
+    recommendation: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)