livepilot 1.19.0 → 1.20.0

package/mcp_server/semantic_moves/routing_compilers.py

@@ -0,0 +1,229 @@
+"""Compilers for routing-domain semantic moves (v1.20).
+
+Each compiler is pure — reads ``kernel["seed_args"]`` for user targets and
+``kernel["session_info"]`` for topology, emits a CompiledPlan of concrete
+tool calls the execution router can dispatch. No I/O, no MCP calls.
+
+Rejection policy: when seed_args are missing/invalid, emit a plan with
+``executable=False`` (empty steps) and a clear warning. This is the v1.20
+contract — see docs/plans/v1.20-structural-plan.md §7.
+"""
+
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_compiler
+from .models import SemanticMove
+
+
+def _return_track_index_to_abs(return_track_index: int) -> int:
+    """Map a 0-based return index to Ableton's negative-track convention.
+
+    Return A (return_track_index=0) → track_index=-1
+    Return B (return_track_index=1) → track_index=-2
+    (See mcp_server/tools/mixing.py:227 — "-1=A, -2=B".)
+    """
+    return -(return_track_index + 1)
+
+
+def _empty_plan(move: SemanticMove, warnings: list[str]) -> CompiledPlan:
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=[],
+        risk_level=move.risk_level,
+        summary="; ".join(warnings) if warnings else "No plan compiled",
+        requires_approval=True,
+        warnings=warnings,
+    )
+
+
+# ── build_send_chain ──────────────────────────────────────────────────────────
+
+
+def _compile_build_send_chain(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    args = kernel.get("seed_args") or {}
+    return_idx = args.get("return_track_index")
+    device_chain = args.get("device_chain")
+    warnings: list[str] = []
+
+    if return_idx is None or device_chain is None:
+        return _empty_plan(move, [
+            "build_send_chain requires seed_args.return_track_index + device_chain"
+        ])
+    if not isinstance(return_idx, int) or return_idx < 0:
+        return _empty_plan(move, [
+            f"return_track_index must be a non-negative int, got {return_idx!r}"
+        ])
+    if not isinstance(device_chain, (list, tuple)) or not device_chain:
+        return _empty_plan(move, [
+            "device_chain is empty — nothing to load onto the return"
+        ])
+    if not all(isinstance(d, str) and d.strip() for d in device_chain):
+        return _empty_plan(move, [
+            "device_chain entries must be non-empty strings (device names)"
+        ])
+
+    abs_track_index = _return_track_index_to_abs(return_idx)
+
+    steps: list[CompiledStep] = []
+    for device_name in device_chain:
+        steps.append(CompiledStep(
+            tool="find_and_load_device",
+            params={
+                "track_index": abs_track_index,
+                "device_name": device_name,
+                # Return chains legitimately may hold two of the same device
+                # (Echo feedback stacking, parallel reverbs). Don't block it.
+                "allow_duplicate": True,
+            },
+            description=f"Load {device_name} onto return {chr(ord('A') + return_idx)}",
+            verify_after=True,
+            backend="remote_command",
+        ))
+
+    # Verify-only read at the end (caller uses this to confirm ordering).
+    steps.append(CompiledStep(
+        tool="get_track_info",
+        params={"track_index": abs_track_index},
+        description="Verify return-track device order after load",
+        verify_after=False,
+        backend="remote_command",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level=move.risk_level,
+        summary=(
+            f"Load {len(device_chain)} device(s) onto return "
+            f"{chr(ord('A') + return_idx)}: {', '.join(device_chain)}"
+        ),
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+# ── configure_send_architecture ───────────────────────────────────────────────
+
+
+def _compile_configure_send_architecture(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    args = kernel.get("seed_args") or {}
+    track_indices = args.get("source_track_indices")
+    send_index = args.get("send_index")
+    levels = args.get("levels")
+
+    if track_indices is None or send_index is None or levels is None:
+        return _empty_plan(move, [
+            "configure_send_architecture requires seed_args.source_track_indices + send_index + levels"
+        ])
+    if not isinstance(track_indices, (list, tuple)) or not track_indices:
+        return _empty_plan(move, ["source_track_indices must be a non-empty list"])
+    if not isinstance(levels, (list, tuple)):
+        return _empty_plan(move, ["levels must be a list"])
+    if len(track_indices) != len(levels):
+        return _empty_plan(move, [
+            f"source_track_indices ({len(track_indices)}) and levels "
+            f"({len(levels)}) must have the same length"
+        ])
+    if not isinstance(send_index, int) or send_index < 0:
+        return _empty_plan(move, [f"send_index must be a non-negative int, got {send_index!r}"])
+
+    warnings: list[str] = []
+    steps: list[CompiledStep] = []
+    for track_i, level in zip(track_indices, levels):
+        if not isinstance(track_i, int):
+            return _empty_plan(move, [f"track_index must be int, got {track_i!r}"])
+        try:
+            level_f = float(level)
+        except (TypeError, ValueError):
+            return _empty_plan(move, [f"level must be numeric, got {level!r}"])
+        clamped = max(0.0, min(1.0, level_f))
+        if clamped != level_f:
+            warnings.append(
+                f"Clamped level {level_f} → {clamped} for track {track_i} "
+                "(send values must be in [0.0, 1.0])"
+            )
+        steps.append(CompiledStep(
+            tool="set_track_send",
+            params={
+                "track_index": track_i,
+                "send_index": send_index,
+                "value": clamped,
+            },
+            description=(
+                f"Set track {track_i} send {send_index} to {clamped:.2f}"
+            ),
+            verify_after=True,
+            backend="remote_command",
+        ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level=move.risk_level,
+        summary=f"Set {len(steps)} send levels on send {send_index}",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+# ── set_track_routing ─────────────────────────────────────────────────────────
+
+
+def _compile_set_track_routing(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    args = kernel.get("seed_args") or {}
+    track_index = args.get("track_index")
+    # Seed_args keeps the ergonomic ``output_routing_type`` /
+    # ``output_routing_channel`` names (matching the MCP tool's public
+    # surface, so the director can type them naturally). But compiled
+    # steps must use the wire-format names — the remote_command backend
+    # bypasses the MCP tool's rename at mcp_server/tools/mixing.py:230
+    # (output_routing_type → output_type). Ableton's Remote Script at
+    # remote_script/LivePilot/mixing.py:227 keys on the wire format.
+    out_type = args.get("output_routing_type")
+    out_channel = args.get("output_routing_channel")
+
+    if track_index is None:
+        return _empty_plan(move, ["set_track_routing requires seed_args.track_index"])
+    if out_type is None and out_channel is None:
+        return _empty_plan(move, [
+            "set_track_routing requires at least output_routing_type or output_routing_channel"
+        ])
+    if not isinstance(track_index, int):
+        return _empty_plan(move, [f"track_index must be int, got {track_index!r}"])
+
+    params: dict = {"track_index": track_index}
+    if out_type is not None:
+        params["output_type"] = str(out_type)
+    if out_channel is not None:
+        params["output_channel"] = str(out_channel)
+
+    step = CompiledStep(
+        tool="set_track_routing",
+        params=params,
+        description=(
+            f"Set track {track_index} output routing → "
+            f"{out_type or '(unchanged)'} / {out_channel or '(unchanged)'}"
+        ),
+        verify_after=True,
+        backend="remote_command",
+    )
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=[step],
+        risk_level=move.risk_level,
+        summary=step.description,
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=[],
+    )
+
+
+# ── Register compilers ────────────────────────────────────────────────────────
+
+register_compiler("build_send_chain", _compile_build_send_chain)
+register_compiler("configure_send_architecture", _compile_configure_send_architecture)
+register_compiler("set_track_routing", _compile_set_track_routing)

package/mcp_server/semantic_moves/routing_moves.py

@@ -0,0 +1,109 @@
+"""Routing-domain semantic moves (v1.20) — build send chains, configure
+send architectures, rewire track outputs.
+
+These moves take user-supplied targets via ``kernel["seed_args"]`` (threaded
+through by ``apply_semantic_move(args=...)`` / ``preview_semantic_move(args=...)``).
+Compilers are pure and live in :mod:`routing_compilers`.
+
+The routing family exists to give the Creative Director Phase 6 a
+semantic_move path for three raw-tool patterns that previously required
+the escape hatch:
+
+    * Loading a chain of devices onto a return track (dub/ambient sends)
+    * Setting send levels across a bunch of source tracks in one move
+    * Rewiring a track's output routing (e.g., "Sends Only")
+"""
+
+from .models import SemanticMove
+from .registry import register
+
+
+BUILD_SEND_CHAIN = SemanticMove(
+    move_id="build_send_chain",
+    family="device_creation",
+    intent=(
+        "Build a device chain on a return track — e.g., a dub Echo → "
+        "Auto Filter → Convolution Reverb send architecture. Takes the "
+        "return_track_index and an ordered device_chain list via seed_args."
+    ),
+    targets={"space": 0.4, "depth": 0.3, "cohesion": 0.3},
+    protect={"low_end": 0.6},
+    risk_level="medium",
+    plan_template=[
+        {
+            "tool": "find_and_load_device",
+            "params": {"description": "Load each device in device_chain onto the return track, in order"},
+            "description": "Load device chain onto return",
+            "backend": "remote_command",
+        },
+    ],
+    verification_plan=[
+        {
+            "tool": "get_track_info",
+            "check": "return track now shows the loaded devices in the expected order",
+            "backend": "remote_command",
+        },
+    ],
+)
+
+CONFIGURE_SEND_ARCHITECTURE = SemanticMove(
+    move_id="configure_send_architecture",
+    family="mix",
+    intent=(
+        "Set send levels across a set of source tracks in a single move — "
+        "e.g., route three source tracks to the Reverb return at balanced "
+        "levels. Takes source_track_indices, send_index, levels via seed_args."
+    ),
+    targets={"space": 0.5, "depth": 0.3, "cohesion": 0.2},
+    protect={"clarity": 0.5},
+    risk_level="low",
+    plan_template=[
+        {
+            "tool": "set_track_send",
+            "params": {"description": "One set_track_send call per (track, level) pair"},
+            "description": "Apply send levels",
+            "backend": "remote_command",
+        },
+    ],
+    verification_plan=[
+        {
+            "tool": "get_track_info",
+            "check": "each source track's send value matches the requested level",
+            "backend": "remote_command",
+        },
+    ],
+)
+
+SET_TRACK_ROUTING_MOVE = SemanticMove(
+    move_id="set_track_routing",
+    family="mix",
+    intent=(
+        "Rewire a track's output routing — e.g., switch an intermediate "
+        "track to 'Sends Only' for a bus architecture. Takes track_index "
+        "plus output_routing_type/channel via seed_args."
+    ),
+    # Routing is topology, not a dimension claim; protect clarity because a
+    # bad routing move can silence the track entirely.
+    targets={},
+    protect={"clarity": 0.5},
+    risk_level="medium",
+    plan_template=[
+        {
+            "tool": "set_track_routing",
+            "params": {"description": "Single set_track_routing call with the provided output fields"},
+            "description": "Rewire track output routing",
+            "backend": "remote_command",
+        },
+    ],
+    verification_plan=[
+        {
+            "tool": "get_track_routing",
+            "check": "output_type and output_channel match the requested values",
+            "backend": "remote_command",
+        },
+    ],
+)
+
+
+for _move in (BUILD_SEND_CHAIN, CONFIGURE_SEND_ARCHITECTURE, SET_TRACK_ROUTING_MOVE):
+    register(_move)

package/mcp_server/semantic_moves/tools.py

@@ -45,6 +45,7 @@ def list_semantic_moves(
 def preview_semantic_move(
     ctx: Context,
     move_id: str,
+    args: Optional[dict] = None,
 ) -> dict:
     """Preview what a semantic move will do before applying it.
 
@@ -54,6 +55,11 @@ def preview_semantic_move(
     tool calls the move would emit right now; use plan_template to understand
     the move's shape independent of session state.
 
+    args (v1.20+): user-supplied seed parameters threaded into the kernel as
+    ``kernel["seed_args"]``. Routing / content / metadata moves require these
+    (e.g., ``{"return_track_index": 0, "device_chain": ["Echo", ...]}``).
+    Pre-v1.20 moves read only from ``session_info`` and ignore seed_args.
+
     Existing callers reading plan_template are unaffected by the addition.
     """
     move = registry.get_move(move_id)
@@ -96,7 +102,10 @@ def preview_semantic_move(
             session_info=session_info,
             capability_state=state.to_dict(),
         )
-        plan = move_compiler.compile(move, kernel.to_dict())
+        kernel_dict = kernel.to_dict()
+        # v1.20: thread user seed_args through to the compiler.
+        kernel_dict["seed_args"] = dict(args) if args else {}
+        plan = move_compiler.compile(move, kernel_dict)
         result["compiled_plan"] = plan.to_dict()
         result["compiled_plan_executable"] = bool(plan.executable)
     except Exception as e:
@@ -285,6 +294,7 @@ async def apply_semantic_move(
     ctx: Context,
     move_id: str,
     mode: str = "improve",
+    args: Optional[dict] = None,
 ) -> dict:
     """Compile and optionally execute a semantic move against the current session.
 
@@ -297,6 +307,12 @@ async def apply_semantic_move(
     - "explore": compile and EXECUTE immediately, capturing before/after.
     - "observe" / "diagnose": compile only, never execute. Return the plan.
 
+    args (v1.20+): user-supplied seed parameters threaded into the kernel as
+    ``kernel["seed_args"]``. Required by routing / content / metadata moves —
+    e.g., ``apply_semantic_move("build_send_chain", mode="explore",
+    args={"return_track_index": 0, "device_chain": ["Echo", "Auto Filter"]})``.
+    Pre-v1.20 moves read only from ``session_info`` and ignore seed_args.
+
     Returns: CompiledPlan with concrete steps, summary, and execution status.
     """
     from . import compiler
@@ -312,6 +328,7 @@ async def apply_semantic_move(
         "session_info": session_info,
         "mode": mode,
         "capability_state": {},
+        "seed_args": dict(args) if args else {},
     }
 
     # Compile the move
@@ -373,9 +390,46 @@ async def apply_semantic_move(
             "ok": er.ok,
         })
 
+    success_count = sum(1 for s in executed_steps if s["ok"])
+    failure_count = sum(1 for s in executed_steps if not s["ok"])
+
+    # v1.20: write the executed move to the SessionLedger so
+    # get_last_move / memory_list / anti-repetition-rules can see it
+    # WITHOUT requiring the director to call add_session_memory
+    # manually. Best-effort — a ledger write failure must not fail
+    # the overall move.
+    ledger_entry_id: Optional[str] = None
+    try:
+        from ..runtime.action_ledger import SessionLedger
+        ledger = ctx.lifespan_context.setdefault("action_ledger", SessionLedger())
+        ledger_entry_id = ledger.start_move(
+            engine="semantic_moves",
+            move_class=move.family,
+            intent=f"{move.move_id}: {move.intent}",
+            undo_scope="micro",
+        )
+        for es in executed_steps:
+            if es["ok"]:
+                ledger.append_action(
+                    ledger_entry_id,
+                    tool_name=es["tool"],
+                    summary=es.get("description", "") or es["tool"],
+                )
+        # Provisional keep — evaluate_move / user undo flip this later.
+        ledger.finalize_move(
+            ledger_entry_id,
+            kept=(failure_count == 0),
+            score=(float(success_count) / len(executed_steps)) if executed_steps else 0.0,
+            memory_candidate=False,
+        )
+    except Exception as exc:  # pragma: no cover — ledger is best-effort
+        logger.warning("apply_semantic_move ledger write failed: %s", exc)
+
     result = plan.to_dict()
     result["executed"] = True
     result["execution_results"] = executed_steps
-    result["success_count"] = sum(1 for s in executed_steps if s["ok"])
-    result["failure_count"] = sum(1 for s in executed_steps if not s["ok"])
+    result["success_count"] = success_count
+    result["failure_count"] = failure_count
+    if ledger_entry_id is not None:
+        result["ledger_entry_id"] = ledger_entry_id
     return result

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 429 tools, 53 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",

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.19.0"
+__version__ = "1.20.0"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.19.0",
+  "version": "1.20.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.19.0",
+      "version": "1.20.0",
       "transport": {
         "type": "stdio"
       }