livepilot 1.9.21 → 1.9.23

package/mcp_server/wonder_mode/tools.py

@@ -0,0 +1,285 @@
+"""Wonder Mode MCP tools — 3 tools for stuck-rescue workflow.
+
+  enter_wonder_mode — diagnose + generate distinct variants + open thread
+  rank_wonder_variants — standalone re-ranker for any variant list
+  discard_wonder_session — reject all variants, keep thread open
+"""
+
+from __future__ import annotations
+
+from fastmcp import Context
+
+from ..server import mcp
+from . import engine
+
+
+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:
+        pass
+    return {}
+
+
+def _get_taste_graph(ctx: Context):
+    """Return the TasteGraph object (not dict) for engine use."""
+    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)
+    except Exception:
+        pass
+    return None
+
+
+def _get_active_constraints():
+    """Read active constraints from creative_constraints module if set."""
+    try:
+        from ..creative_constraints.tools import _active_constraints
+        return _active_constraints
+    except Exception:
+        return None
+
+
+def _get_ledger_entries(ctx: Context) -> list[dict]:
+    """Get recent action ledger entries as dicts."""
+    try:
+        from ..runtime.action_ledger import SessionLedger
+        ledger: SessionLedger = ctx.lifespan_context.setdefault(
+            "action_ledger", SessionLedger()
+        )
+        entries = ledger.get_recent_moves(limit=20)
+        return [e.to_dict() for e in entries]
+    except Exception:
+        return []
+
+
+def _get_stuckness_report(ctx: Context, song_brain: dict) -> dict | None:
+    """Run stuckness detection on recent actions if available."""
+    try:
+        from ..stuckness_detector.detector import detect_stuckness
+        action_ledger = _get_ledger_entries(ctx)
+        if not action_ledger:
+            return None
+        # Pass session_info if available for better accuracy
+        session_info = {}
+        try:
+            ableton = ctx.lifespan_context.get("ableton")
+            if ableton:
+                session_info = ableton.send_command("get_session_info", {})
+        except Exception:
+            pass
+        report = detect_stuckness(
+            action_history=action_ledger,
+            session_info=session_info,
+            song_brain=song_brain,
+        )
+        return report.to_dict()
+    except Exception:
+        return None
+
+
+@mcp.tool()
+def enter_wonder_mode(
+    ctx: Context,
+    request_text: str,
+    kernel_id: str = "",
+) -> dict:
+    """Activate Wonder Mode — stuck-rescue workflow with real diagnosis.
+
+    Diagnoses why the session needs creative rescue, generates 1-3
+    genuinely distinct executable variants (plus honest analytical
+    fallbacks), and opens a creative thread for tracking.
+
+    Returns wonder_session_id for use with create_preview_set,
+    commit_preview_variant, and discard_wonder_session.
+
+    request_text: the creative request or description of being stuck
+    kernel_id: optional session kernel reference
+    """
+    if not request_text.strip():
+        return {"error": "request_text cannot be empty"}
+
+    from .diagnosis import build_diagnosis
+    from .session import WonderSession, store_wonder_session
+
+    song_brain = _get_song_brain_dict()
+    taste_graph = _get_taste_graph(ctx)
+    active_constraints = _get_active_constraints()
+    action_ledger = _get_ledger_entries(ctx)
+    stuckness_report = _get_stuckness_report(ctx, song_brain)
+
+    # 1. Build diagnosis
+    diagnosis = build_diagnosis(
+        stuckness_report=stuckness_report,
+        song_brain=song_brain,
+        action_ledger=action_ledger,
+    )
+
+    # 2. Generate variants
+    result = engine.generate_wonder_variants(
+        request_text=request_text,
+        diagnosis=diagnosis.to_dict(),
+        kernel_id=kernel_id,
+        song_brain=song_brain,
+        taste_graph=taste_graph,
+        active_constraints=active_constraints,
+    )
+
+    # 3. Create WonderSession (unique per invocation, not deterministic)
+    import hashlib, time
+    _seed = f"{request_text}:{kernel_id}:{time.time()}"
+    session_id = "ws_" + hashlib.sha256(_seed.encode()).hexdigest()[:12]
+    ws = WonderSession(
+        session_id=session_id,
+        request_text=request_text,
+        kernel_id=kernel_id,
+        diagnosis=diagnosis,
+        variants=result["variants"],
+        recommended=result.get("recommended", ""),
+        variant_count_actual=result.get("variant_count_actual", 0),
+        degraded_reason=result.get("degraded_reason", ""),
+        status="diagnosing",  # will transition below
+    )
+    ws.transition_to("variants_ready")
+
+    # 4. Open creative thread (exploration, NOT turn resolution)
+    try:
+        from ..session_continuity.tracker import open_thread
+        thread_domain = diagnosis.candidate_domains[0] if diagnosis.candidate_domains else "exploration"
+        thread = open_thread(
+            description=f"Wonder: {request_text}",
+            domain=thread_domain,
+        )
+        ws.creative_thread_id = thread.thread_id
+    except Exception:
+        pass
+
+    # 5. Store session
+    store_wonder_session(ws)
+
+    # 6. Return full response (NO turn resolution recorded here)
+    return {
+        "wonder_session_id": ws.session_id,
+        "creative_thread_id": ws.creative_thread_id,
+        "diagnosis": diagnosis.to_dict(),
+        "variants": result["variants"],
+        "recommended": result.get("recommended", ""),
+        "variant_count_actual": result.get("variant_count_actual", 0),
+        "degraded_reason": ws.degraded_reason,
+        "mode": "wonder",
+    }
+
+
+@mcp.tool()
+def rank_wonder_variants(
+    ctx: Context,
+    variants: list[dict] | None = None,
+) -> dict:
+    """Rank wonder-mode variants by taste + identity + novelty + coherence.
+
+    Standalone re-ranker for any list of variant dicts. Preserves ALL
+    input fields (what_changed, compiled_plan, move_id, targets_snapshot).
+
+    Uses the current SongBrain and session taste graph for scoring.
+    When input dicts lack targets_snapshot, sacred element penalty
+    is skipped gracefully.
+
+    variants: list of variant dicts with at least variant_id,
+              novelty_level, identity_effect, taste_fit fields
+
+    Returns ranked list with composite scores, breakdowns, and recommendation.
+    """
+    if not variants:
+        return {"error": "No variants provided", "rankings": []}
+
+    song_brain = _get_song_brain_dict()
+    taste_graph = _get_taste_graph(ctx)
+
+    novelty_band = 0.5
+    taste_evidence = 0
+    if taste_graph is not None:
+        novelty_band = taste_graph.novelty_band
+        taste_evidence = taste_graph.evidence_count
+
+    ranked = engine.rank_variants(
+        variant_dicts=[dict(v) for v in variants],  # copy to avoid mutating input
+        song_brain=song_brain,
+        novelty_band=novelty_band,
+        taste_evidence=taste_evidence,
+    )
+
+    return {
+        "rankings": ranked,
+        "recommended": ranked[0]["variant_id"] if ranked else "",
+    }
+
+
+@mcp.tool()
+def discard_wonder_session(
+    ctx: Context,
+    wonder_session_id: str,
+) -> dict:
+    """Reject all Wonder variants and close the session.
+
+    The creative thread stays open — the problem isn't solved.
+    Records a rejected turn resolution and updates taste.
+
+    wonder_session_id: the session to discard
+    """
+    from .session import get_wonder_session
+
+    ws = get_wonder_session(wonder_session_id)
+    if not ws:
+        return {"error": "Wonder session not found", "wonder_session_id": wonder_session_id}
+
+    if not ws.transition_to("resolved"):
+        return {"error": f"Cannot discard session in '{ws.status}' state", "wonder_session_id": wonder_session_id}
+
+    ws.outcome = "rejected_all"
+
+    # Record rejected turn
+    try:
+        from ..session_continuity.tracker import record_turn_resolution
+        record_turn_resolution(
+            request_text=ws.request_text,
+            outcome="rejected",
+            move_applied="",
+            identity_effect="",
+            user_sentiment="disliked",
+        )
+    except Exception:
+        pass
+
+    # Update taste graph — rejection is a negative signal for all executable variants
+    try:
+        taste_graph = _get_taste_graph(ctx)
+        if taste_graph:
+            for v in ws.variants:
+                if not v.get("analytical_only") and v.get("move_id") and v.get("family"):
+                    taste_graph.record_move_outcome(
+                        move_id=v["move_id"],
+                        family=v["family"],
+                        kept=False,
+                    )
+    except Exception:
+        pass
+
+    # Discard linked preview set
+    if ws.preview_set_id:
+        try:
+            from ..preview_studio.engine import discard_set
+            discard_set(ws.preview_set_id)
+        except Exception:
+            pass
+
+    return {
+        "discarded": True,
+        "wonder_session_id": wonder_session_id,
+        "thread_still_open": bool(ws.creative_thread_id),
+    }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.9.21",
+  "version": "1.9.23",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 237 tools, 32 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "description": "Agentic production system for Ableton Live 12 — 293 tools, 39 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",
   "license": "MIT",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.9.21"
+__version__ = "1.9.23"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/remote_script/LivePilot/browser.py

@@ -184,10 +184,13 @@ def search_browser(song, params):
     _search_recursive(item, name_filter, loadable_only, results, 0, max_depth,
                       max_results)
     truncated = len(results) >= max_results
-    result = {"path": path, "results": results, "count": len(results)}
+    result = {"path": path, "items": results, "total_results": len(results)}
     if truncated:
         result["truncated"] = True
         result["max_results"] = max_results
+    # Legacy alias for backward compatibility
+    result["results"] = results
+    result["count"] = len(results)
     return result
 
 

package/remote_script/LivePilot/devices.py

@@ -209,6 +209,35 @@ def delete_device(song, params):
     return {"deleted": device_index}
 
 
+@register("move_device")
+def move_device(song, params):
+    """Move a device to a new position on the same or different track.
+
+    Uses Song.move_device(device, target_track, target_index).
+    """
+    track_index = int(params["track_index"])
+    device_index = int(params["device_index"])
+    target_index = int(params.get("target_index", device_index))
+    target_track_index = params.get("target_track_index", None)
+
+    track = get_track(song, track_index)
+    device = get_device(track, device_index)
+
+    if target_track_index is not None:
+        target_track = get_track(song, int(target_track_index))
+    else:
+        target_track = track
+
+    song.move_device(device, target_track, target_index)
+    return {
+        "moved": device.name,
+        "from_track": track_index,
+        "from_index": device_index,
+        "to_track": int(target_track_index) if target_track_index is not None else track_index,
+        "to_index": target_index,
+    }
+
+
 @register("load_device_by_uri")
 def load_device_by_uri(song, params):
     """Load a device onto a track using a browser URI.

package/remote_script/LivePilot/tracks.py

@@ -120,8 +120,9 @@ def create_midi_track(song, params):
     track = list(song.tracks)[new_index]
     if "name" in params:
         track.name = str(params["name"])
-    if "color_index" in params:
-        track.color_index = int(params["color_index"])
+    color = params.get("color_index", params.get("color", None))
+    if color is not None:
+        track.color_index = int(color)
     # Ableton auto-arms newly created tracks — disarm to avoid surprises
     if track.arm and not params.get("arm", False):
         track.arm = False
@@ -140,8 +141,9 @@ def create_audio_track(song, params):
     track = list(song.tracks)[new_index]
     if "name" in params:
         track.name = str(params["name"])
-    if "color_index" in params:
-        track.color_index = int(params["color_index"])
+    color = params.get("color_index", params.get("color", None))
+    if color is not None:
+        track.color_index = int(color)
     # Ableton auto-arms newly created tracks — disarm to avoid surprises
     if track.arm and not params.get("arm", False):
         track.arm = False
@@ -157,6 +159,11 @@ def create_return_track(song, params):
     return {"index": new_index, "name": return_tracks[new_index].name}
 
 
+# NOTE: move_track is not supported by the Live Object Model.
+# Tracks can only be created, deleted, and duplicated — not reordered.
+# Users must reorder tracks manually in Ableton's GUI.
+
+
 @register("delete_track")
 def delete_track(song, params):
     """Delete a track by index."""

package/scripts/generate_tool_catalog.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Generate tool catalog from live runtime metadata.
+
+Produces a markdown tool catalog validated against mcp.list_tools().
+This is the single source of truth — hand-edited catalogs are replaced.
+
+Usage: python3 scripts/generate_tool_catalog.py > docs/manual/tool-catalog-generated.md
+"""
+
+import asyncio
+import inspect
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+
+def get_tools() -> list[dict]:
+    """Get all registered tools with metadata."""
+    from mcp_server.server import mcp
+
+    tools_raw = asyncio.run(mcp.list_tools())
+    tools = []
+    for t in tools_raw:
+        # Get the module path to determine domain
+        func = t.fn if hasattr(t, "fn") else None
+        module = ""
+        if func:
+            module = func.__module__ if hasattr(func, "__module__") else ""
+
+        # Get parameter names
+        params = []
+        if func:
+            sig = inspect.signature(func)
+            for name, param in sig.parameters.items():
+                if name == "ctx":
+                    continue
+                required = param.default is inspect.Parameter.empty
+                params.append({"name": name, "required": required})
+
+        tools.append({
+            "name": t.name,
+            "description": t.description[:120] if hasattr(t, "description") and t.description else "",
+            "module": module,
+            "params": params,
+        })
+
+    return tools
+
+
+def infer_domain(module: str) -> str:
+    """Infer domain from module path."""
+    if "semantic_moves" in module:
+        return "Semantic Moves"
+    if "experiment" in module:
+        return "Experiments"
+    if "musical_intelligence" in module:
+        return "Musical Intelligence"
+    if "memory.tools" in module:
+        return "Memory Fabric"
+    if "mix_engine" in module:
+        return "Mix Engine"
+    if "sound_design" in module:
+        return "Sound Design"
+    if "transition_engine" in module:
+        return "Transition Engine"
+    if "reference_engine" in module:
+        return "Reference Engine"
+    if "translation_engine" in module:
+        return "Translation Engine"
+    if "performance_engine" in module:
+        return "Performance Engine"
+    if "project_brain" in module:
+        return "Project Brain"
+    if "evaluation" in module:
+        return "Evaluation"
+    if "runtime" in module:
+        return "Runtime"
+
+    # Core tools — extract from module name
+    parts = module.split(".")
+    for p in reversed(parts):
+        if p in ("transport", "tracks", "clips", "notes", "devices", "scenes",
+                  "mixing", "browser", "arrangement", "memory", "analyzer",
+                  "automation", "theory", "generative", "harmony", "midi_io",
+                  "perception", "agent_os", "composition", "motif", "research",
+                  "planner"):
+            return p.replace("_", " ").title()
+
+    return "Other"
+
+
+def main():
+    tools = get_tools()
+    total = len(tools)
+
+    # Group by domain
+    domains = defaultdict(list)
+    for t in tools:
+        domain = infer_domain(t["module"])
+        domains[domain].append(t)
+
+    print(f"# LivePilot — Full Tool Catalog (Generated)")
+    print()
+    print(f"{total} tools across {len(domains)} domains.")
+    print()
+    print("> Auto-generated from `mcp.list_tools()`. Do not hand-edit.")
+    print("> Regenerate: `python3 scripts/generate_tool_catalog.py`")
+    print()
+    print("---")
+    print()
+
+    for domain in sorted(domains.keys()):
+        tool_list = sorted(domains[domain], key=lambda t: t["name"])
+        print(f"## {domain} ({len(tool_list)})")
+        print()
+        print("| Tool | Description |")
+        print("|------|-------------|")
+        for t in tool_list:
+            desc = t["description"].split("\n")[0].strip()
+            print(f"| `{t['name']}` | {desc} |")
+        print()
+
+    print(f"---")
+    print(f"*Generated from {total} registered tools.*")
+
+
+if __name__ == "__main__":
+    main()