livepilot 1.20.2 → 1.21.0

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

@@ -1913,3 +1913,128 @@ async def compressor_set_sidechain(
         params["source_channel"] = str(source_channel)
     ableton = ctx.lifespan_context["ableton"]
     return ableton.send_command("set_compressor_sidechain", params)
+
+
+# ──────────────────────────────────────────────────────────────────────
+# v1.20.3 — ensure_analyzer_on_master
+#
+# Motivated by the v1.20.1 live-test campaign operator-error (see
+# ~/Desktop/DREAM AI/demo Project/REPORT.md). The LLM operator had a
+# clear global-memory instruction to load LivePilot_Analyzer on master
+# proactively on a fresh session, and missed it — leaving analyzer-
+# gated moves brittle. This tool closes that class of error by making
+# the load idempotent + automatable.
+
+_ANALYZER_DEVICE_NAME = "LivePilot_Analyzer"
+
+
+def _load_analyzer_impl(ctx, track_index: int, device_name: str,
+                        allow_duplicate: bool = False) -> dict:
+    """Indirection so tests can monkeypatch the load call without having
+    to fake the full find_and_load_device MCP-tool machinery. Production
+    calls straight through to the existing tool."""
+    from .devices import find_and_load_device
+    return find_and_load_device(
+        ctx,
+        track_index=track_index,
+        device_name=device_name,
+        allow_duplicate=allow_duplicate,
+    )
+
+
+@mcp.tool()
+def ensure_analyzer_on_master(ctx: Context) -> dict:
+    """Idempotent pre-flight: load LivePilot_Analyzer on master if missing.
+
+    Safe to call at the start of any session or before any move that
+    declares analyzer dependency. Calling it repeatedly is cheap —
+    subsequent calls short-circuit via a single get_master_track read.
+
+    CLAUDE.md invariant: "LivePilot_Analyzer must be LAST on master."
+    This tool reports whether the invariant holds via ``is_last_on_master``;
+    it does NOT move the device (that's a user action in Ableton's GUI).
+
+    Return shape:
+    - status: one of {"already_loaded", "loaded", "install_required", "failed"}
+    - device_index: int  — position of the analyzer on master (when present)
+    - is_last_on_master: bool — True when analyzer is the last device
+    - duplicate_count: int — 2+ when multiple analyzers exist (shouldn't)
+    - warning: str | None — surfaces last-on-master violations
+    - hint: str — actionable next step when status != "already_loaded"/"loaded"
+    - error: str | None — present on status="failed"
+    """
+    ableton = ctx.lifespan_context["ableton"]
+
+    # 1. Inspect the master chain for an existing analyzer.
+    try:
+        master = ableton.send_command("get_master_track")
+    except Exception as exc:
+        return {
+            "status": "failed",
+            "error": f"Could not read master track: {exc}",
+            "hint": "Verify MCP connection to Ableton; retry with get_session_info first.",
+        }
+
+    devices = (master or {}).get("devices") or []
+    matches = [d for d in devices if d.get("name") == _ANALYZER_DEVICE_NAME]
+
+    if matches:
+        # 2. Already loaded — build a status report without side effects.
+        first = matches[0]
+        device_index = first.get("index")
+        is_last = False
+        if devices:
+            last_name = devices[-1].get("name")
+            is_last = (last_name == _ANALYZER_DEVICE_NAME)
+
+        result: dict = {
+            "status": "already_loaded",
+            "device_index": device_index,
+            "is_last_on_master": is_last,
+            "duplicate_count": len(matches),
+        }
+        if len(matches) > 1:
+            result["warning"] = (
+                f"{len(matches)} instances of {_ANALYZER_DEVICE_NAME} on master — "
+                "only one is needed. Remove extras in Ableton's GUI."
+            )
+        elif not is_last:
+            result["warning"] = (
+                f"{_ANALYZER_DEVICE_NAME} is not the LAST device on master. "
+                "CLAUDE.md invariant requires it to come after ALL effects so "
+                "it reads the final output, not pre-effect signal. "
+                "Move it to the end of the master chain in Ableton's GUI."
+            )
+        return result
+
+    # 3. Not on master — try loading from the Ableton browser.
+    try:
+        loaded = _load_analyzer_impl(
+            ctx,
+            track_index=-1000,  # master convention
+            device_name=_ANALYZER_DEVICE_NAME,
+            allow_duplicate=False,
+        )
+    except Exception as exc:
+        # Typical path: device not in browser (user hasn't installed via
+        # install_m4l_device yet).
+        return {
+            "status": "install_required",
+            "error": str(exc),
+            "hint": (
+                "LivePilot_Analyzer not found in Ableton's browser. Install "
+                "first with install_m4l_device(source_path="
+                "\"<repo>/m4l_device/LivePilot_Analyzer.amxd\") — that copies "
+                "the .amxd into ~/Music/Ableton/User Library/Presets/Audio "
+                "Effects/Max Audio Effect/. Then call ensure_analyzer_on_master "
+                "again to complete the load."
+            ),
+        }
+
+    device_index = (loaded or {}).get("device_index")
+    return {
+        "status": "loaded",
+        "device_index": device_index,
+        "is_last_on_master": True,  # fresh load always lands at the end
+        "duplicate_count": 1,
+    }

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.2",
+  "version": "1.21.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)",
+  "description": "Agentic production system for Ableton Live 12 — 430 tools, 53 domains, 43 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.2"
+__version__ = "1.21.0"
 
 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": "429-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, 43 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.2",
+  "version": "1.21.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.20.2",
+      "version": "1.21.0",
       "transport": {
         "type": "stdio"
       }