livepilot 1.18.2 → 1.19.0

package/mcp_server/experiment/baseline.py

@@ -0,0 +1,138 @@
+"""Experiment baseline transport state — capture once, restore between branches.
+
+v1.19 Item A: running N branches sequentially produces inconsistent
+``before_snapshot`` values because playback position, mute/solo/arm, and
+playing-clip state drift across branches. ``undo()`` reverts command
+history but doesn't guarantee transport state is identical at the start
+of each branch's capture window.
+
+Flow in ``run_experiment``:
+
+1. Before the first branch: ``capture_baseline(ableton)`` and stash on
+   the :class:`ExperimentSet`.
+2. Between branches (before capturing the next before_snapshot): call
+   ``restore_baseline(ableton, baseline)`` to stop transport, reset
+   mute/solo/arm, and pause briefly for meters to settle.
+
+The module is deliberately thin — no LOM subscription, no state
+monitoring. Just a snapshot dataclass + two functions.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class BaselineTransportState:
+    """Transport + per-track state captured before the first experiment branch.
+
+    Kept deliberately shallow: we don't try to freeze automation or scene
+    state. Those are out of scope (plan §2 "What NOT to do" — automation
+    drift is an accepted limitation).
+    """
+
+    is_playing: bool = False
+    song_time: float = 0.0
+    track_states: list[dict] = field(default_factory=list)
+    captured_at_ms: int = 0
+
+    def to_dict(self) -> dict:
+        return {
+            "is_playing": self.is_playing,
+            "song_time": self.song_time,
+            "track_states": list(self.track_states),
+            "captured_at_ms": self.captured_at_ms,
+        }
+
+
+def capture_baseline(ableton) -> BaselineTransportState:
+    """Capture current transport + per-track state.
+
+    Uses ``get_session_info`` (single round-trip for all fields we need).
+    Returns a frozen-in-time snapshot; subsequent state drift doesn't
+    affect it.
+    """
+    info = ableton.send_command("get_session_info")
+    if not isinstance(info, dict):
+        info = {}
+
+    tracks = info.get("tracks") or []
+    track_states: list[dict] = []
+    for i, t in enumerate(tracks):
+        if not isinstance(t, dict):
+            continue
+        track_states.append({
+            "index": int(t.get("index", i)),
+            "mute": bool(t.get("mute", False)),
+            "solo": bool(t.get("solo", False)),
+            "arm": bool(t.get("arm", False)),
+        })
+
+    return BaselineTransportState(
+        is_playing=bool(info.get("is_playing", False)),
+        song_time=float(info.get("current_song_time", 0.0) or 0.0),
+        track_states=track_states,
+        captured_at_ms=int(time.time() * 1000),
+    )
+
+
+def restore_baseline(
+    ableton,
+    baseline: BaselineTransportState,
+    stabilize_ms: int = 300,
+) -> None:
+    """Restore transport + per-track state to the captured baseline.
+
+    Sequence:
+      1. ``stop_playback`` (halt transport — also stops any live clips)
+      2. For each track: ``set_track_mute`` / ``set_track_solo`` /
+         ``set_track_arm`` (best-effort; per-track failure is logged,
+         not fatal — a single flaky track should never abort restore
+         for the rest).
+      3. Sleep ``stabilize_ms`` milliseconds so meters settle before the
+         next ``before_snapshot`` reads them. Pass ``0`` in tests.
+
+    We deliberately do NOT seek the transport to ``baseline.song_time``.
+    Returning from stopped transport is enough — re-seeking a stopped
+    transport is equivalent to not moving, and on a playing transport it
+    introduces its own stutter artefact. If a future branch needs timeline
+    position consistency, add a ``jump_to_time`` call here.
+
+    Return-track arms are skipped — ``set_track_arm`` on a negative index
+    raises (return tracks aren't armable in Live).
+    """
+    try:
+        ableton.send_command("stop_playback")
+    except Exception as exc:
+        logger.debug("restore_baseline stop_playback failed: %s", exc)
+
+    for ts in baseline.track_states:
+        idx = ts.get("index", -1)
+        try:
+            ableton.send_command("set_track_mute", {
+                "track_index": idx, "mute": bool(ts.get("mute", False)),
+            })
+        except Exception as exc:
+            logger.debug("restore_baseline set_track_mute(%s) failed: %s", idx, exc)
+        try:
+            ableton.send_command("set_track_solo", {
+                "track_index": idx, "solo": bool(ts.get("solo", False)),
+            })
+        except Exception as exc:
+            logger.debug("restore_baseline set_track_solo(%s) failed: %s", idx, exc)
+        if idx >= 0:
+            try:
+                ableton.send_command("set_track_arm", {
+                    "track_index": idx, "arm": bool(ts.get("arm", False)),
+                })
+            except Exception as exc:
+                logger.debug("restore_baseline set_track_arm(%s) failed: %s", idx, exc)
+
+    if stabilize_ms > 0:
+        time.sleep(stabilize_ms / 1000.0)

package/mcp_server/experiment/engine.py

@@ -445,3 +445,23 @@ def discard_experiment(experiment_id: str) -> dict:
     exp.status = "discarded"
 
     return {"discarded": True, "experiment_id": experiment_id}
+
+
+# ── v1.19 Item A — between-branch baseline restore ───────────────────────────
+
+
+def prepare_for_next_branch(ableton, baseline, stabilize_ms: int = 300) -> None:
+    """Restore baseline transport state before capturing the next branch.
+
+    Called by ``run_experiment`` between branches so each branch's
+    ``before_snapshot`` reads from identical starting conditions. No-op
+    when ``baseline`` is None (first branch — the baseline was just
+    captured, no drift to correct).
+
+    Thin wrapper around ``baseline.restore_baseline``; exists so the
+    MCP tool body stays small and the wiring is testable in isolation.
+    """
+    if baseline is None:
+        return
+    from .baseline import restore_baseline
+    restore_baseline(ableton, baseline, stabilize_ms=stabilize_ms)

package/mcp_server/experiment/models.py

@@ -19,6 +19,7 @@ from dataclasses import dataclass, field
 from typing import Any, Optional
 
 from ..branches import BranchSeed
+from .baseline import BaselineTransportState
 
 
 @dataclass
@@ -249,6 +250,10 @@ class ExperimentSet:
     status: str = "open"  # open | evaluated | committed | discarded
     winner_branch_id: Optional[str] = None
     created_at_ms: int = 0
+    # v1.19 Item A — transport state captured before the first branch runs
+    # and used to restore identical starting conditions between branches.
+    # See mcp_server.experiment.baseline for the snapshot / restore pair.
+    baseline_transport: Optional[BaselineTransportState] = None
 
     @property
     def branch_count(self) -> int:
@@ -290,7 +295,7 @@ class ExperimentSet:
         return _branch_rank_key(branch)
 
     def to_dict(self) -> dict:
-        return {
+        d = {
             "experiment_id": self.experiment_id,
             "request_text": self.request_text,
             "status": self.status,
@@ -302,3 +307,6 @@ class ExperimentSet:
                 for b in self.ranked_branches()
             ],
         }
+        if self.baseline_transport is not None:
+            d["baseline_transport"] = self.baseline_transport.to_dict()
+        return d

package/mcp_server/experiment/tools.py

@@ -343,11 +343,33 @@ async def run_experiment(
     # Import compiler
     from ..semantic_moves import registry, compiler
 
+    # v1.19 Item A — capture baseline transport state BEFORE any branch runs.
+    # Each branch's before_snapshot is only comparable if it starts from the
+    # same reference state. Without this, live testing (v1.18.0 Test 8) showed
+    # 3 branches produce wildly inconsistent before_snapshot.track_meters[0].level
+    # values — clip stopped mid-experiment between branches.
+    if experiment.baseline_transport is None:
+        from .baseline import capture_baseline
+        try:
+            experiment.baseline_transport = capture_baseline(ableton)
+        except Exception as exc:
+            logger.debug("baseline capture failed: %s", exc)
+            experiment.baseline_transport = None
+
     results = []
+    pending_seen = 0
     for branch in experiment.branches:
         if branch.status != "pending":
             continue
 
+        # Between branches (not before the first), restore the baseline so
+        # the next before_snapshot reads from the same reference state.
+        if pending_seen > 0:
+            engine.prepare_for_next_branch(
+                ableton, experiment.baseline_transport, stabilize_ms=300,
+            )
+        pending_seen += 1
+
         # PR3: respect a pre-existing compiled_plan on the branch (freeform /
         # synthesis / composer producers bring their own). Only compile from
         # move_id when the branch arrived without a plan — which requires a

package/mcp_server/server.py

@@ -301,6 +301,7 @@ from .stuckness_detector import tools as stuckness_tools       # noqa: F401, E40
 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
+from .creative_director import tools as creative_director_tools  # noqa: F401, E402
 from .device_forge import tools as device_forge_tools          # noqa: F401, E402
 from .sample_engine import tools as sample_engine_tools        # noqa: F401, E402
 from .atlas import tools as atlas_tools                        # noqa: F401, E402

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.18.2",
+  "version": "1.19.0",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 427 tools, 52 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 — 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",
   "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.18.2"
+__version__ = "1.19.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": "427-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
+  "description": "429-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.18.2",
+  "version": "1.19.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.18.2",
+      "version": "1.19.0",
       "transport": {
         "type": "stdio"
       }