livepilot 1.9.21 → 1.9.23

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"},
+        {"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"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "energy increasing, all tracks alive"},
+    ],
+)
+
+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"},
+        {"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"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "overall energy increased, stereo field wider"},
+        {"tool": "analyze_mix", "check": "no clipping, stereo.mono_risk is false"},
+    ],
+)
+
+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"},
+        {"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"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "energy significantly reduced, at least one element still prominent"},
+    ],
+)
+
+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"},
+        {"tool": "set_track_volume", "params": {"description": "Gentle volume crossfade between section elements"}, "description": "Crossfade elements"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "smooth level transition, no dropouts"},
+    ],
+)
+
+# 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/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)

package/mcp_server/session_continuity/tools.py

@@ -0,0 +1,230 @@
+"""Session Continuity MCP tools — 7 tools for collaborative memory.
+
+  get_session_story — what the track was becoming, what changed, what's open
+  resume_last_intent — pick up where you left off
+  record_turn_resolution — log what happened in a creative turn
+  rank_by_taste_and_identity — rank candidates with separated taste/identity
+  open_creative_thread — open a new creative thread for exploration
+  list_open_creative_threads — list all open non-stale creative threads
+  explain_preference_vs_identity — explain taste vs identity tension
+"""
+
+from __future__ import annotations
+
+from fastmcp import Context
+
+from ..server import mcp
+from . import tracker
+
+
+@mcp.tool()
+def get_session_story(ctx: Context) -> dict:
+    """Get the narrative of the current session.
+
+    At the start of a resumed session, the agent can say what the track
+    was trying to become, what changed last time, and what still feels open.
+
+    Returns identity summary, recent turns, open creative threads,
+    and mood arc.
+    """
+    song_brain = _get_song_brain_dict()
+    story = tracker.get_session_story(song_brain)
+    return story.to_dict()
+
+
+@mcp.tool()
+def resume_last_intent(ctx: Context) -> dict:
+    """Resume the most recent unresolved creative intent.
+
+    Finds the latest open creative thread and suggests continuing it.
+    Stale threads (untouched for >30 minutes) are excluded.
+    """
+    return tracker.resume_last_intent()
+
+
+@mcp.tool()
+def record_turn_resolution(
+    ctx: Context,
+    request_text: str,
+    outcome: str = "accepted",
+    move_applied: str = "",
+    identity_effect: str = "",
+    user_sentiment: str = "neutral",
+) -> dict:
+    """Record what happened in a creative turn.
+
+    Call this after each significant creative action to build the
+    session story. Tracks outcomes, identity effects, and user sentiment.
+
+    request_text: what was requested
+    outcome: "accepted", "rejected", "modified", or "undone"
+    move_applied: which semantic move was used (if any)
+    identity_effect: "preserves", "evolves", "contrasts", or "resets"
+    user_sentiment: "loved", "liked", "neutral", "disliked", or "hated"
+    """
+    turn = tracker.record_turn_resolution(
+        request_text=request_text,
+        outcome=outcome,
+        move_applied=move_applied,
+        identity_effect=identity_effect,
+        user_sentiment=user_sentiment,
+    )
+    return turn.to_dict()
+
+
+@mcp.tool()
+def rank_by_taste_and_identity(
+    ctx: Context,
+    candidates: list[dict] | None = None,
+) -> dict:
+    """Rank candidates with separated taste and identity scoring.
+
+    Taste (cross-session preference) ranks options.
+    Identity (in-song) constrains/shapes options.
+    Explicit user instructions override both.
+
+    candidates: list of dicts with at least "id", "novelty_level",
+                and "identity_effect" fields
+
+    Returns ranked list with taste_score, identity_score, composite,
+    and explanations for each.
+    """
+    if not candidates:
+        return {"error": "No candidates provided", "rankings": []}
+
+    taste_graph = _get_taste_graph(ctx)
+    song_brain = _get_song_brain_dict()
+
+    rankings = tracker.rank_by_taste_and_identity(
+        candidates=candidates,
+        taste_graph=taste_graph,
+        song_brain=song_brain,
+    )
+
+    return {
+        "rankings": [r.to_dict() for r in rankings],
+        "note": "Identity has stronger weight inside a session; taste has stronger weight when choosing among viable options",
+    }
+
+
+@mcp.tool()
+def open_creative_thread(
+    ctx: Context,
+    description: str,
+    domain: str = "",
+    priority: float = 0.5,
+) -> dict:
+    """Open a new creative thread — an unresolved creative goal.
+
+    Use this to track intentions that span multiple actions, like
+    "develop the chorus hook" or "fix the transition energy."
+    Threads are surfaced by get_session_story and resume_last_intent.
+
+    description: what the creative goal is
+    domain: "arrangement", "sound_design", "mix", "harmony", "identity"
+    priority: 0-1 importance level
+    """
+    if not description.strip():
+        return {"error": "description cannot be empty"}
+
+    thread = tracker.open_thread(description, domain=domain, priority=priority)
+    return thread.to_dict()
+
+
+@mcp.tool()
+def list_open_creative_threads(ctx: Context) -> dict:
+    """List all open (non-stale) creative threads in the session.
+
+    Returns unresolved creative goals, abandoned directions worth
+    revisiting, and what the next best unresolved question is.
+    Stale threads (untouched for >30 minutes) are excluded.
+    """
+    threads = tracker.list_open_threads()
+
+    return {
+        "threads": [t.to_dict() for t in threads],
+        "thread_count": len(threads),
+        "next_best": threads[0].to_dict() if threads else None,
+        "note": "Threads decay after 30 minutes of inactivity",
+    }
+
+
+@mcp.tool()
+def explain_preference_vs_identity(
+    ctx: Context,
+    candidate_id: str = "",
+    novelty_level: float = 0.5,
+    identity_effect: str = "preserves",
+) -> dict:
+    """Explain how taste preference and song identity score a candidate.
+
+    Shows the tension between what the user tends to like (taste)
+    and what the current song needs (identity). Useful for understanding
+    why a variant was ranked the way it was.
+
+    candidate_id: the candidate to explain
+    novelty_level: 0-1 how novel the candidate is
+    identity_effect: "preserves", "evolves", "contrasts", or "resets"
+    """
+    taste_graph = _get_taste_graph(ctx)
+    song_brain = _get_song_brain_dict()
+
+    candidates = [{
+        "id": candidate_id,
+        "novelty_level": novelty_level,
+        "identity_effect": identity_effect,
+    }]
+
+    rankings = tracker.rank_by_taste_and_identity(
+        candidates=candidates,
+        taste_graph=taste_graph,
+        song_brain=song_brain,
+    )
+
+    if not rankings:
+        return {"error": "Could not rank candidate"}
+
+    r = rankings[0]
+    return {
+        "candidate_id": candidate_id,
+        "taste_score": r.taste_score,
+        "identity_score": r.identity_score,
+        "composite_score": r.composite_score,
+        "taste_explanation": r.taste_explanation,
+        "identity_explanation": r.identity_explanation,
+        "recommendation": r.recommendation,
+        "tension": (
+            "aligned" if abs(r.taste_score - r.identity_score) < 0.2
+            else "in tension — taste and identity disagree"
+        ),
+        "note": "Identity has stronger weight inside a session (0.65 vs 0.35)",
+    }
+
+
+# ── Helpers ───────────────────────────────────────────────────────
+
+
+def _get_song_brain_dict() -> dict:
+    try:
+        from ..song_brain.tools import _current_brain
+        if _current_brain is not None:
+            return _current_brain.to_dict()
+    except Exception as _e:
+        if __debug__:
+            import sys
+            print(f"LivePilot: SongBrain unavailable in session_continuity: {_e}", file=sys.stderr)
+    return {}
+
+
+def _get_taste_graph(ctx: Context) -> dict:
+    """Session-scoped taste graph — matches preview_studio pattern."""
+    try:
+        from ..memory.taste_graph import build_taste_graph
+        from ..memory.taste_memory import TasteMemoryStore
+        from ..memory.anti_memory import AntiMemoryStore
+        taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
+        anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
+        return build_taste_graph(taste_store=taste_store, anti_store=anti_store).to_dict()
+    except Exception:
+        pass
+    return {}