livepilot 1.20.3 → 1.21.1

package/mcp_server/semantic_moves/device_mutation_compilers.py

@@ -27,14 +27,30 @@ def _empty_plan(move: SemanticMove, warnings: list[str]) -> CompiledPlan:
 
 
 def _compile_configure_device(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile configure_device.
+
+    v1.20 contract: seed_args.param_overrides (explicit dict of
+    {param_name: value}).
+
+    v1.21 additions (additive — v1.20 callers unaffected):
+      - seed_args.preset: str        — named preset in the affordance library
+      - seed_args.device_slug: str   — required when preset is used; v1.21
+                                       does not auto-infer from class_name
+
+    Merge contract: preset resolves first, then explicit param_overrides
+    entries merge on top (last-write-wins at dict-key granularity).
+    """
     args = kernel.get("seed_args") or {}
     track_index = args.get("track_index")
     device_index = args.get("device_index")
-    overrides = args.get("param_overrides")
+    explicit_overrides = args.get("param_overrides")
+    preset_name = args.get("preset")
+    device_slug = args.get("device_slug")
 
-    if track_index is None or device_index is None or overrides is None:
+    if track_index is None or device_index is None:
         return _empty_plan(move, [
-            "configure_device requires seed_args.track_index + device_index + param_overrides"
+            "configure_device requires seed_args.track_index + device_index "
+            "(plus either param_overrides or a preset+device_slug pair)"
         ])
     if not isinstance(track_index, int) or not isinstance(device_index, int):
         return _empty_plan(move, [
@@ -43,14 +59,49 @@ def _compile_configure_device(move: SemanticMove, kernel: dict) -> CompiledPlan:
         ])
     if device_index < 0:
         return _empty_plan(move, [f"device_index must be non-negative, got {device_index}"])
-    if not isinstance(overrides, dict):
+
+    # explicit param_overrides is now optional (may be None if preset provides
+    # everything), but when present must be a dict.
+    if explicit_overrides is not None and not isinstance(explicit_overrides, dict):
         return _empty_plan(move, [
-            f"param_overrides must be a dict[str, Any], got {type(overrides).__name__}"
+            f"param_overrides must be a dict[str, Any], got "
+            f"{type(explicit_overrides).__name__}"
         ])
-    if not overrides:
+
+    # v1.21: resolve preset if requested
+    preset_overrides: dict = {}
+    if preset_name is not None:
+        if not device_slug:
+            return _empty_plan(move, [
+                "preset seed_arg requires device_slug (v1.21 contract — "
+                "auto-inference from class_name is v1.22 scope). Example: "
+                "args={\"track_index\": -1, \"device_index\": 0, "
+                "\"device_slug\": \"reverb\", \"preset\": \"dub-cathedral\"}"
+            ])
+        # Late import so mcp_server.semantic_moves doesn't hard-depend on
+        # mcp_server.affordances at import time — branch is only taken
+        # when a caller explicitly asks for a preset.
+        from ..affordances import resolve_preset
+        resolved = resolve_preset(device_slug, preset_name)
+        if resolved is None:
+            return _empty_plan(move, [
+                f"No preset {preset_name!r} for device slug {device_slug!r}. "
+                f"Check mcp_server/affordances/devices/{device_slug}.yaml "
+                f"exists and contains the named preset."
+            ])
+        preset_overrides = resolved
+
+    # Merge: preset resolves first, explicit param_overrides merge on top
+    # (last-write-wins at dict-key granularity).
+    merged: dict = dict(preset_overrides)
+    if explicit_overrides:
+        merged.update(explicit_overrides)
+
+    if not merged:
         return _empty_plan(move, [
-            "param_overrides is empty — nothing to configure (delete_device "
-            "is a different move)"
+            "configure_device requires either a non-empty param_overrides "
+            "dict OR a preset+device_slug combination that resolves to "
+            "params. Neither was provided."
         ])
 
     # WIRE-FORMAT NOTE: compiled steps use the remote_command backend,
@@ -61,9 +112,12 @@ def _compile_configure_device(move: SemanticMove, kernel: dict) -> CompiledPlan:
     # exclusively. Emit that key directly.
     parameters = [
         {"name_or_index": str(name), "value": value}
-        for name, value in overrides.items()
+        for name, value in merged.items()
     ]
 
+    preset_suffix = (
+        f" from preset {device_slug}/{preset_name}" if preset_name else ""
+    )
     step = CompiledStep(
         tool="batch_set_parameters",
         params={
@@ -72,9 +126,9 @@ def _compile_configure_device(move: SemanticMove, kernel: dict) -> CompiledPlan:
             "parameters": parameters,
         },
         description=(
-            f"Configure device at track {track_index}, device_index {device_index} — "
-            f"set {len(parameters)} parameter(s): "
-            f"{', '.join(p['name_or_index'] for p in parameters)}"
+            f"Configure device at track {track_index}, device_index "
+            f"{device_index}{preset_suffix} — set {len(parameters)} "
+            f"parameter(s): {', '.join(p['name_or_index'] for p in parameters)}"
         ),
         verify_after=True,
         backend="remote_command",

package/mcp_server/semantic_moves/performance_compilers.py

@@ -200,9 +200,166 @@ def _compile_emergency_simplify(move: SemanticMove, kernel: dict) -> CompiledPla
     )
 
 
+def _compile_configure_record_readiness(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile configure_record_readiness.
+
+    seed_args:
+      track_index: int   — required; must be >= 0 (return tracks can't be armed)
+      armed: bool        — required
+      exclusive: bool    — optional, default False
+
+    Steps:
+      exclusive=True + armed=True
+          → N+1 steps: set_track_arm(other_idx, arm=False) for every
+            regular track ≠ target, then set_track_arm(target, arm=True).
+          — Emulates Ableton's exclusive-arm mode manually. Cannot use
+            ``set_exclusive_arm`` directly: ``song.exclusive_arm`` has
+            no Python setter in Live 12.4 (property getter only — a
+            pre-existing v1.20.3 Remote Script bug surfaced during v1.21's
+            live-test pre-flight). The manual disarm loop produces the
+            same user-facing outcome (target is the single armed track)
+            without depending on the broken toggle.
+      else
+          → [set_track_arm(track_index, arm=armed)]
+
+    Wire-format discipline: emit `arm` (not `armed`). The remote_command
+    backend bypasses the MCP tool rename layer (``tools/tracks.py:317``
+    renames ``armed → arm`` before send_command), so the compiler must
+    emit ``arm`` directly. See remote_script/LivePilot/tracks.py:263
+    for the Remote Script handler.
+    """
+    args = kernel.get("seed_args") or {}
+    track_index = args.get("track_index")
+    armed = args.get("armed")
+    exclusive = args.get("exclusive", False)
+
+    # Required-seed-args
+    if track_index is None or armed is None:
+        return CompiledPlan(
+            move_id=move.move_id,
+            intent=move.intent,
+            summary="missing required seed_args",
+            warnings=[
+                "configure_record_readiness requires seed_args.track_index "
+                "(int) and seed_args.armed (bool). Example: "
+                "apply_semantic_move(\"configure_record_readiness\", "
+                "mode=\"explore\", args={\"track_index\": 0, \"armed\": True})"
+            ],
+        )
+    if not isinstance(track_index, int):
+        return CompiledPlan(
+            move_id=move.move_id, intent=move.intent,
+            summary="invalid track_index type",
+            warnings=[f"track_index must be int, got {type(track_index).__name__}"],
+        )
+    if not isinstance(armed, bool):
+        return CompiledPlan(
+            move_id=move.move_id, intent=move.intent,
+            summary="invalid armed type",
+            warnings=[f"armed must be bool, got {type(armed).__name__}"],
+        )
+    if not isinstance(exclusive, bool):
+        return CompiledPlan(
+            move_id=move.move_id, intent=move.intent,
+            summary="invalid exclusive type",
+            warnings=[f"exclusive must be bool, got {type(exclusive).__name__}"],
+        )
+
+    # Contradiction: exclusive requires armed
+    if exclusive and not armed:
+        return CompiledPlan(
+            move_id=move.move_id, intent=move.intent,
+            summary="contradictory exclusive+armed",
+            warnings=[
+                "exclusive=True requires armed=True (the point of exclusive "
+                "is to become the single armed track); to disarm individually "
+                "call configure_record_readiness with exclusive=False"
+            ],
+        )
+
+    # Return-track constraint (Ableton's handler rejects negative indices)
+    if track_index < 0:
+        return CompiledPlan(
+            move_id=move.move_id, intent=move.intent,
+            summary="return tracks cannot be armed",
+            warnings=[
+                f"Cannot arm a return track (track_index={track_index}). "
+                "Ableton's set_track_arm handler rejects negative indices "
+                "(remote_script/LivePilot/tracks.py:261). Provide a regular "
+                "track index (>= 0)."
+            ],
+        )
+
+    steps: list[CompiledStep] = []
+    if exclusive and armed:
+        # Manual emulation of Ableton's exclusive-arm mode (set_exclusive_arm
+        # handler is broken in Live 12.4 per above docstring). Emit N+1
+        # steps: disarm every other regular track, then arm target.
+        all_tracks = kernel.get("session_info", {}).get("tracks", []) or []
+        if not all_tracks:
+            return CompiledPlan(
+                move_id=move.move_id, intent=move.intent,
+                summary="exclusive mode requires session_info.tracks",
+                warnings=[
+                    "configure_record_readiness exclusive=True requires "
+                    "session_info.tracks to know which other tracks to disarm. "
+                    "apply_semantic_move builds session_info automatically; "
+                    "direct compiler callers must supply it explicitly."
+                ],
+            )
+        for track in all_tracks:
+            idx = track.get("index")
+            if idx is None or idx == track_index:
+                continue
+            # Skip return / master — can't be armed anyway, and Ableton's
+            # set_track_arm rejects negative indices (tracks.py:261).
+            if track.get("type") in ("return", "master"):
+                continue
+            if isinstance(idx, int) and idx < 0:
+                continue
+            name = track.get("name", f"track {idx}")
+            steps.append(CompiledStep(
+                tool="set_track_arm",
+                params={"track_index": idx, "arm": False},
+                description=f"Disarm {name} (exclusive-arm emulation)",
+                backend="remote_command",
+            ))
+        steps.append(CompiledStep(
+            tool="set_track_arm",
+            params={"track_index": track_index, "arm": True},
+            description=(
+                f"Arm track {track_index} "
+                f"(exclusive — single-armed, {len(steps)} other(s) disarmed)"
+            ),
+            backend="remote_command",
+        ))
+        summary = (
+            f"Exclusive-arm track {track_index} — "
+            f"{len(steps)-1} other regular track(s) disarmed first"
+        )
+    else:
+        steps.append(CompiledStep(
+            tool="set_track_arm",
+            params={"track_index": track_index, "arm": armed},
+            description=f"{'Arm' if armed else 'Disarm'} track {track_index}",
+            backend="remote_command",
+        ))
+        summary = f"{'Arm' if armed else 'Disarm'} track {track_index}"
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level=move.risk_level,
+        summary=summary,
+        requires_approval=False,  # Performance moves execute immediately
+    )
+
+
 # ── Register ────────────────────────────────────────────────────────────────
 
 register_compiler("recover_energy", _compile_recover_energy)
 register_compiler("decompress_tension", _compile_decompress_tension)
 register_compiler("safe_spotlight", _compile_safe_spotlight)
 register_compiler("emergency_simplify", _compile_emergency_simplify)
+register_compiler("configure_record_readiness", _compile_configure_record_readiness)

package/mcp_server/semantic_moves/performance_moves.py

@@ -76,6 +76,51 @@ EMERGENCY_SIMPLIFY = SemanticMove(
     ],
 )
 
+# v1.21: configure_record_readiness — closes the tech_debt entry from
+# v1.20 live test 6 (raw set_track_arm without a semantic-move wrapper).
+# seed_args: {track_index: int, armed: bool, exclusive?: bool = False}.
+# Note: `armed` here is the *ergonomic* seed_arg name — the compiler
+# translates it to the wire-format key `arm` per remote_script/LivePilot/
+# tracks.py:263. See _compile_configure_record_readiness.
+CONFIGURE_RECORD_READINESS = SemanticMove(
+    move_id="configure_record_readiness",
+    family="performance",
+    intent=(
+        "Arm or disarm a track for recording. When exclusive=True, disarms "
+        "all other regular tracks then arms the target — the standard "
+        "one-take recording setup (Live 12.4's `song.exclusive_arm` toggle "
+        "is read-only from Python, so the compiler emulates the mode via "
+        "a manual disarm loop)."
+    ),
+    targets={},
+    protect={"signal_integrity": 0.7},
+    risk_level="low",
+    required_capabilities=["session"],
+    plan_template=[
+        # Informational — compiler builds concrete steps from seed_args.
+        {
+            "tool": "set_track_arm",
+            "params": {"description": "Arm or disarm the target track"},
+            "description": "Toggle track arm",
+            "backend": "remote_command",
+        },
+    ],
+    verification_plan=[
+        {
+            "tool": "get_track_info",
+            "check": "track's arm field matches requested value",
+            "backend": "remote_command",
+        },
+    ],
+)
+
+
 # Register all performance moves
-for _move in [RECOVER_ENERGY, DECOMPRESS_TENSION, SAFE_SPOTLIGHT, EMERGENCY_SIMPLIFY]:
+for _move in [
+    RECOVER_ENERGY,
+    DECOMPRESS_TENSION,
+    SAFE_SPOTLIGHT,
+    EMERGENCY_SIMPLIFY,
+    CONFIGURE_RECORD_READINESS,  # v1.21
+]:
     register(_move)

package/mcp_server/semantic_moves/tools.py

@@ -397,11 +397,14 @@ async def apply_semantic_move(
     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.
+    # store_purpose: writer
+    # v1.20: apply_semantic_move is the canonical semantic-moves writer
+    # to the SessionLedger. Downstream anti-repetition / stuckness /
+    # song-brain readers (annotated store_purpose: anti_repetition) consume
+    # entries this block writes. commit_experiment (v1.21) mirrors this
+    # pattern with a "composer|experiment" engine tag instead of
+    # "semantic_moves". 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

package/mcp_server/song_brain/tools.py

@@ -139,6 +139,12 @@ def _fetch_session_data(ctx: Context) -> dict:
     except Exception as exc:
         logger.debug("_fetch_session_data failed: %s", exc)
 
+    # store_purpose: anti_repetition
+    # song_brain's _fetch_session_data surfaces recent moves into the
+    # brain's context so section analysis can detect repeated work
+    # patterns. Recency signal — NOT the persistent technique library.
+    # Correct store: SessionLedger.get_recent_moves (v1.20 director SKILL
+    # previously pointed at memory_list for this, which was wrong).
     # Recent moves — from session-scoped action ledger
     try:
         from ..runtime.action_ledger import SessionLedger

package/mcp_server/stuckness_detector/tools.py

@@ -27,6 +27,10 @@ def _get_action_history(ctx: Context) -> list[dict]:
     repeated undos, local-tweaking, loop-without-structure detection.
     Falls back to empty list when no ledger data exists (graceful degradation).
     """
+    # store_purpose: anti_repetition
+    # Stuckness detection reads recent_moves to spot repeated undos,
+    # local-tweaking loops, and loop-without-structure patterns.
+    # Recency signal — NOT the persistent technique library.
     try:
         from ..runtime.action_ledger import SessionLedger
         ledger = ctx.lifespan_context.get("action_ledger")

package/mcp_server/tools/_agent_os_engine/taste.py

@@ -14,6 +14,12 @@ from typing import Any, Optional
 from .models import QUALITY_DIMENSIONS, _clamp
 
 
+# store_purpose: technique_library
+# analyze_outcome_history consumes payloads from the persistent
+# technique library (memory_list(type="outcome")) — NOT recency data.
+# Taste-inference work reads accumulated outcome records, unlike
+# anti-repetition which reads SessionLedger.get_recent_moves.
+
 # ── Outcome Memory Analysis (Round 1) ────────────────────────────────
 def analyze_outcome_history(outcomes: list[dict]) -> dict:
     """Analyze accumulated outcome memories to identify user taste patterns.

package/mcp_server/tools/memory.py

@@ -150,6 +150,13 @@ def _generate_replay_steps(technique: dict) -> list[str]:
     return ["Replay the technique from the stored payload"]
 
 
+# store_purpose: mcp_tool_definition
+# memory_list is the MCP tool for browsing the persistent technique
+# library (memory_learn-populated). Callers that use its output for
+# anti-repetition recency have the v1.20 store-confusion BUG: correct
+# pattern is SessionLedger.get_recent_moves or get_action_ledger_summary.
+# The test tests/test_ledger_readers.py::TestAntiRepetitionUsesLedgerNotMemoryList
+# enforces this invariant across the codebase.
 @mcp.tool()
 def memory_list(
     ctx: Context,

package/mcp_server/wonder_mode/tools.py

@@ -148,6 +148,10 @@ def _get_active_constraints():
 
 def _get_ledger_entries(ctx: Context) -> list[dict]:
     """Get recent action ledger entries as dicts."""
+    # store_purpose: anti_repetition
+    # Wonder Mode's rescue trigger reads recent_moves to feed the
+    # stuckness detector — classic recency signal, NOT the persistent
+    # technique library. Correct store: SessionLedger.get_recent_moves.
     try:
         from ..runtime.action_ledger import SessionLedger
         ledger: SessionLedger = ctx.lifespan_context.setdefault(

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.20.3",
+  "version": "1.21.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 430 tools, 53 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
+  "description": "Agentic production system for Ableton Live 12 — 430 tools, 53 domains, 44 semantic moves. Device atlas (1305 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "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.20.3"
+__version__ = "1.21.1"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "430-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
+  "description": "430-tool agentic MCP production system for Ableton Live 12 — 53 domains, 44 semantic moves, device atlas (1305 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.20.3",
+  "version": "1.21.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.20.3",
+      "version": "1.21.1",
       "transport": {
         "type": "stdio"
       }