livepilot 1.27.2 → 1.27.3

package/mcp_server/persistence/project_store.py

@@ -7,16 +7,35 @@ Located at ~/.livepilot/projects/<hash>/state.json.
 from __future__ import annotations
 
 import hashlib
+import logging
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Optional
 
 from .base_store import PersistentJsonStore
 
+logger = logging.getLogger(__name__)
+
 
 _PROJECTS_DIR = Path.home() / ".livepilot" / "projects"
 _MAX_TURNS = 50
 _MAX_WONDER_OUTCOMES = 10
+# Creative threads accumulate one entry per open_thread() call, and
+# session_continuity mints a fresh thread_id (ms-timestamp-seeded hash) every
+# time — unlike turns/wonder_outcomes there was previously NO cap here, so
+# the list grew monotonically forever and every save_thread() became a
+# full read-modify-write over an ever-larger threads array.
+_MAX_THREADS = 100
+
+# Schema version of the on-disk shape this build writes/expects.
+CURRENT_VERSION = 1
+
+# Migration table: source version -> callable that upgrades data from that
+# version to the next. Empty today — CURRENT_VERSION has been 1 since this
+# store existed. Scaffolding for the day a schema bump actually needs a real
+# migration; until then any version mismatch backs up the raw file and warns
+# instead of silently discarding the project's threads/turns/wonder history.
+_MIGRATIONS: dict[int, Callable[[dict], dict]] = {}
 
 
 def project_hash(session_info: dict) -> str:
@@ -86,6 +105,41 @@ def project_hash(session_info: dict) -> str:
     return hashlib.sha256(seed.encode()).hexdigest()[:12]
 
 
+def _prune_threads(threads: list[dict], max_threads: int) -> list[dict]:
+    """Cap the thread list, preferring to drop resolved threads first.
+
+    Mirrors the capping pattern already used by save_turn (_MAX_TURNS) and
+    save_wonder_outcome (_MAX_WONDER_OUTCOMES) — but threads never had one,
+    and open_thread() mints a fresh thread_id every call, so the list grew
+    monotonically forever.
+
+    Eviction order:
+      1. Resolved threads, oldest-touched first — a long resolved history
+         shouldn't crowd out genuinely open creative threads.
+      2. If resolved threads alone aren't enough to reach the cap, fall back
+         to dropping the oldest-touched threads overall (any status), so the
+         most-recently-touched threads always survive.
+    """
+    if len(threads) <= max_threads:
+        return threads
+
+    overflow = len(threads) - max_threads
+
+    resolved_idx = sorted(
+        (i for i, t in enumerate(threads) if t.get("status") == "resolved"),
+        key=lambda i: threads[i].get("last_touched_ms", 0),
+    )
+    drop: set[int] = set(resolved_idx[:overflow])
+
+    if len(drop) < overflow:
+        remaining_idx = [i for i in range(len(threads)) if i not in drop]
+        remaining_idx.sort(key=lambda i: threads[i].get("last_touched_ms", 0))
+        need_more = overflow - len(drop)
+        drop.update(remaining_idx[:need_more])
+
+    return [t for i, t in enumerate(threads) if i not in drop]
+
+
 class ProjectStore:
     """Persistent per-project state."""
 
@@ -98,28 +152,98 @@ class ProjectStore:
     def project_id(self) -> str:
         return self._project_id
 
+    def _coerce(self, data: dict) -> dict:
+        """Return schema-current data — migrating forward or resetting.
+
+        - version == CURRENT_VERSION: pass through unchanged (hot path).
+        - version has a registered migration chain to CURRENT_VERSION: run it.
+        - anything else (missing/non-int version, or a version this build
+          doesn't know how to migrate — e.g. it's newer than this build):
+          back up the raw file to ``<path>.pre-migration``, log a WARNING,
+          and fall back to defaults. Never silently discard.
+        """
+        version = data.get("version")
+        if version == CURRENT_VERSION:
+            return data
+        migrated = self._migrate(data, version)
+        if migrated is not None:
+            return migrated
+        if data:
+            self._backup_unmigrated(version)
+        return self._default()
+
+    @staticmethod
+    def _migrate(data: dict, version) -> Optional[dict]:
+        """Run the migration chain from ``version`` to CURRENT_VERSION.
+
+        Returns None if there's no registered path (unknown/future version),
+        signalling the caller to fall back to defaults.
+        """
+        if not isinstance(version, int):
+            return None
+        migrated = dict(data)
+        seen: set[int] = set()
+        while migrated.get("version") != CURRENT_VERSION:
+            v = migrated.get("version")
+            if not isinstance(v, int) or v in seen or v not in _MIGRATIONS:
+                return None
+            seen.add(v)
+            migrated = _MIGRATIONS[v](migrated)
+        return migrated
+
+    def _backup_unmigrated(self, version) -> None:
+        """Preserve the raw on-disk file before falling back to defaults."""
+        path = self._store.path
+        backup = path.with_suffix(path.suffix + ".pre-migration")
+        try:
+            if path.exists():
+                path.replace(backup)
+                logger.warning(
+                    "ProjectStore(%s): unrecognized schema version %r in %s "
+                    "(expected %r) — backed up to %s and falling back to "
+                    "defaults; the original data was NOT discarded",
+                    self._project_id, version, path, CURRENT_VERSION, backup,
+                )
+            else:
+                logger.warning(
+                    "ProjectStore(%s): unrecognized schema version %r "
+                    "(expected %r, no on-disk file to back up) — falling "
+                    "back to defaults",
+                    self._project_id, version, CURRENT_VERSION,
+                )
+        except OSError as exc:
+            logger.warning(
+                "ProjectStore(%s): failed to back up unrecognized-version "
+                "file %s (%s) — falling back to defaults without a backup",
+                self._project_id, path, exc,
+            )
+
     def get_all(self) -> dict:
         data = self._store.read()
-        return data if data.get("version") == 1 else self._default()
+        return self._coerce(data)
 
     def save_thread(self, thread: dict) -> None:
-        """Save or update a creative thread."""
+        """Save or update a creative thread (capped at _MAX_THREADS)."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             threads = data.setdefault("threads", [])
             # Update existing or append
             for i, t in enumerate(threads):
                 if t.get("thread_id") == thread.get("thread_id"):
                     threads[i] = thread
-                    return data
-            threads.append(thread)
+                    break
+            else:
+                threads.append(thread)
+            if len(threads) > _MAX_THREADS:
+                threads = _prune_threads(threads, _MAX_THREADS)
+            data["threads"] = threads
             return data
         self._store.update(_update)
 
     def save_turn(self, turn: dict) -> None:
         """Save a turn resolution (capped at MAX_TURNS)."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             turns = data.setdefault("turns", [])
             turns.append(turn)
             # Cap at max
@@ -132,7 +256,7 @@ class ProjectStore:
     def save_wonder_outcome(self, outcome: dict) -> None:
         """Save a Wonder session outcome (capped at MAX_WONDER_OUTCOMES)."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             outcomes = data.setdefault("wonder_outcomes", [])
             outcomes.append(outcome)
             if len(outcomes) > _MAX_WONDER_OUTCOMES:

package/mcp_server/persistence/taste_store.py

@@ -7,15 +7,31 @@ anti-preferences, and dimension weights. Located at
 
 from __future__ import annotations
 
+import logging
 import time
 from pathlib import Path
-from typing import Optional
+from typing import Callable, Optional
 
 from .base_store import PersistentJsonStore
 
+logger = logging.getLogger(__name__)
+
 
 _DEFAULT_PATH = Path.home() / ".livepilot" / "taste.json"
 
+# Schema version of the on-disk shape this build writes/expects.
+CURRENT_VERSION = 1
+
+# Migration table: source version -> callable that upgrades data from that
+# version to the next. Empty today — CURRENT_VERSION has been 1 since this
+# store existed, so there has never been a real migration to run. This is
+# scaffolding: when a future schema bump lands, add `{OLD: _migrate_fn}` here
+# and bump CURRENT_VERSION. Without this table, ANY version mismatch (a
+# future bump, a downgrade, a hand-edited file) silently discarded the
+# user's entire taste/anti-preference history back to defaults with no
+# warning and no backup — that's the bug this scaffolding closes.
+_MIGRATIONS: dict[int, Callable[[dict], dict]] = {}
+
 
 class PersistentTasteStore:
     """Persistent backing for TasteGraph data."""
@@ -23,17 +39,84 @@ class PersistentTasteStore:
     def __init__(self, path: Optional[Path] = None):
         self._store = PersistentJsonStore(path or _DEFAULT_PATH)
 
+    def _coerce(self, data: dict) -> dict:
+        """Return schema-current data — migrating forward or resetting.
+
+        - version == CURRENT_VERSION: pass through unchanged (hot path).
+        - version has a registered migration chain to CURRENT_VERSION: run it.
+        - anything else (missing/non-int version, or a version this build
+          doesn't know how to migrate — e.g. it's newer than this build):
+          back up the raw file to ``<path>.pre-migration``, log a WARNING,
+          and fall back to defaults. Never silently discard.
+        """
+        version = data.get("version")
+        if version == CURRENT_VERSION:
+            return data
+        migrated = self._migrate(data, version)
+        if migrated is not None:
+            return migrated
+        if data:
+            self._backup_unmigrated(version)
+        return self._default()
+
+    @staticmethod
+    def _migrate(data: dict, version) -> Optional[dict]:
+        """Run the migration chain from ``version`` to CURRENT_VERSION.
+
+        Returns None if there's no registered path (unknown/future version),
+        signalling the caller to fall back to defaults.
+        """
+        if not isinstance(version, int):
+            return None
+        migrated = dict(data)
+        seen: set[int] = set()
+        while migrated.get("version") != CURRENT_VERSION:
+            v = migrated.get("version")
+            if not isinstance(v, int) or v in seen or v not in _MIGRATIONS:
+                return None
+            seen.add(v)
+            migrated = _MIGRATIONS[v](migrated)
+        return migrated
+
+    def _backup_unmigrated(self, version) -> None:
+        """Preserve the raw on-disk file before falling back to defaults."""
+        path = self._store.path
+        backup = path.with_suffix(path.suffix + ".pre-migration")
+        try:
+            if path.exists():
+                path.replace(backup)
+                logger.warning(
+                    "PersistentTasteStore: unrecognized schema version %r in "
+                    "%s (expected %r) — backed up to %s and falling back to "
+                    "defaults; the original data was NOT discarded",
+                    version, path, CURRENT_VERSION, backup,
+                )
+            else:
+                logger.warning(
+                    "PersistentTasteStore: unrecognized schema version %r "
+                    "(expected %r, no on-disk file to back up) — falling "
+                    "back to defaults",
+                    version, CURRENT_VERSION,
+                )
+        except OSError as exc:
+            logger.warning(
+                "PersistentTasteStore: failed to back up unrecognized-"
+                "version file %s (%s) — falling back to defaults without "
+                "a backup",
+                path, exc,
+            )
+
     def get_all(self) -> dict:
         """Get all persisted taste data."""
         data = self._store.read()
-        return data if data.get("version") == 1 else self._default()
+        return self._coerce(data)
 
     def record_move_outcome(
         self, move_id: str, family: str, kept: bool, score: float = 0.0,
     ) -> None:
         """Persist a move outcome."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             outcomes = data.setdefault("move_outcomes", {})
             entry = outcomes.setdefault(move_id, {
                 "family": family, "kept_count": 0, "undone_count": 0,
@@ -57,7 +140,7 @@ class PersistentTasteStore:
         field mirrors the "improve" band.
         """
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             # Ensure the per-mode dict exists (migrating from legacy shape).
             bands = data.get("novelty_bands")
             if not isinstance(bands, dict) or not bands:
@@ -78,7 +161,7 @@ class PersistentTasteStore:
     def record_device_use(self, device_name: str, positive: bool = True) -> None:
         """Persist device affinity."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             affinities = data.setdefault("device_affinities", {})
             entry = affinities.setdefault(device_name, {
                 "affinity": 0.0, "use_count": 0,
@@ -96,7 +179,7 @@ class PersistentTasteStore:
     def record_anti_preference(self, dimension: str, direction: str) -> None:
         """Persist an anti-preference."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             antis = data.setdefault("anti_preferences", [])
             existing = next(
                 (a for a in antis if a["dimension"] == dimension and a["direction"] == direction),
@@ -117,7 +200,7 @@ class PersistentTasteStore:
     def record_dimension_weight(self, dimension: str, value: float) -> None:
         """Persist a dimension weight update."""
         def _update(data: dict) -> dict:
-            data = data if data.get("version") == 1 else self._default()
+            data = self._coerce(data)
             data.setdefault("dimension_weights", {})[dimension] = round(value, 3)
             return data
         self._store.update(_update)

package/mcp_server/preview_studio/engine.py

@@ -8,29 +8,43 @@ from __future__ import annotations
 
 import hashlib
 import json
+import threading
 import time
 from typing import Optional
 
 from ..runtime.degradation import DegradationInfo
-from .models import PreviewSet, PreviewVariant
+from .models import PreviewSet, PreviewVariant, compute_session_fingerprint
 
 
 # ── In-memory store ───────────────────────────────────────────────
+#
+# _preview_sets is mutated from both threadpooled sync tools (e.g.
+# compare_preview_variants) and event-loop async tools (e.g.
+# commit_preview_variant) — two concurrent create_preview_set calls used to
+# be able to race in store_preview_set's check-then-evict loop: both read
+# the same `oldest_key`, both `del` it, and the second raised KeyError. One
+# module-level lock around the get/store/evict critical sections closes
+# that race.
 
 _preview_sets: dict[str, PreviewSet] = {}
+_preview_sets_lock = threading.Lock()
 _MAX_PREVIEW_SETS = 20
 
 
 def get_preview_set(set_id: str) -> Optional[PreviewSet]:
-    return _preview_sets.get(set_id)
+    with _preview_sets_lock:
+        return _preview_sets.get(set_id)
 
 
 def store_preview_set(ps: PreviewSet) -> None:
-    _preview_sets[ps.set_id] = ps
-    # Evict oldest sets if over limit
-    while len(_preview_sets) > _MAX_PREVIEW_SETS:
-        oldest_key = next(iter(_preview_sets))
-        del _preview_sets[oldest_key]
+    with _preview_sets_lock:
+        _preview_sets[ps.set_id] = ps
+        # Evict oldest sets if over limit
+        while len(_preview_sets) > _MAX_PREVIEW_SETS:
+            oldest_key = next(iter(_preview_sets), None)
+            if oldest_key is None:
+                break
+            _preview_sets.pop(oldest_key, None)
 
 
 # Statuses that represent work a user (or caller) has already invested in:
@@ -50,13 +64,13 @@ def _resolve_set_id(base_id: str) -> str:
     to a distinct, still-deterministic id (base_id + a monotonic suffix) so the
     protected set survives and the new set gets its own slot.
     """
-    existing = _preview_sets.get(base_id)
+    existing = get_preview_set(base_id)
     if existing is None or existing.status not in _PROTECTED_STATUSES:
         return base_id
     suffix = 2
     while True:
         candidate = f"{base_id}_b{suffix}"
-        occupant = _preview_sets.get(candidate)
+        occupant = get_preview_set(candidate)
         if occupant is None or occupant.status not in _PROTECTED_STATUSES:
             return candidate
         suffix += 1
@@ -86,6 +100,13 @@ def create_preview_set(
         synthesizes an empty-but-valid kernel (see ``_build_triptych``) and
         flags the resulting PreviewSet with ``degradation.is_degraded=True``
         so callers can tell a synthesized compile from a real one.
+
+        When kernel carries a real ``session_info`` (track topology), the
+        resulting PreviewSet is stamped with a session_fingerprint so a
+        later commit can detect that the session's track/device layout
+        changed since this plan's indices were compiled — no extra Ableton
+        round-trip is made here, we just hash data the caller already
+        fetched.
     """
     set_id = _resolve_set_id(_compute_set_id(request_text, kernel_id))
     now = int(time.time() * 1000)
@@ -117,6 +138,13 @@ def create_preview_set(
             request_text, moves, song_brain, taste_graph, set_id, now, kernel,
         )
 
+    # Stamp session identity from data the caller already fetched (kernel's
+    # session_info) — never a new round-trip. Absent/synthesized kernels
+    # yield "", which downstream commit checks treat as "no signal".
+    session_fingerprint = compute_session_fingerprint(
+        (kernel or {}).get("session_info")
+    )
+
     ps = PreviewSet(
         set_id=set_id,
         request_text=request_text,
@@ -125,6 +153,7 @@ def create_preview_set(
         variants=variants,
         created_at_ms=now,
         degradation=degradation,
+        session_fingerprint=session_fingerprint,
     )
     store_preview_set(ps)
     return ps
@@ -433,7 +462,8 @@ def commit_variant(preview_set: PreviewSet, variant_id: str) -> Optional[Preview
 
 def discard_set(set_id: str) -> bool:
     """Discard an entire preview set."""
-    ps = _preview_sets.pop(set_id, None)
+    with _preview_sets_lock:
+        ps = _preview_sets.pop(set_id, None)
     if ps:
         ps.status = "discarded"
         for v in ps.variants:

package/mcp_server/preview_studio/models.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import hashlib
+import json
 import time
 from dataclasses import asdict, dataclass, field
 from typing import Optional
@@ -9,6 +11,38 @@ from typing import Optional
 from ..runtime.degradation import DegradationInfo
 
 
+def compute_session_fingerprint(session_info: Optional[dict]) -> str:
+    """Lightweight fingerprint of session topology (track_count + ordered
+    track names).
+
+    PreviewSet and WonderSession cache compiled plans that reference
+    positional track/device indices. Those indices are only valid against
+    the session topology that existed when the plan was compiled — if the
+    user adds/removes/reorders tracks before the plan is committed, replaying
+    those indices can silently hit the wrong track.
+
+    This helper is the single source of truth for that fingerprint, shared
+    by preview_studio and wonder_mode so both stamp/verify it the same way.
+    Callers stamp it at creation time from session_info they already fetched
+    (never triggers its own Ableton round-trip). At commit/replay time they
+    fetch a fresh session_info and compare fingerprints.
+
+    Returns "" when session_info is missing/malformed — an empty fingerprint
+    means "no signal available" and callers must skip the staleness check
+    (this keeps older cached/persisted objects, built before this field
+    existed, committable).
+    """
+    if not isinstance(session_info, dict) or not session_info:
+        return ""
+    tracks = session_info.get("tracks")
+    if not isinstance(tracks, list):
+        tracks = []
+    names = [str(t.get("name", "")) for t in tracks if isinstance(t, dict)]
+    track_count = session_info.get("track_count", len(names))
+    seed = json.dumps({"track_count": track_count, "track_names": names}, sort_keys=True)
+    return hashlib.sha256(seed.encode()).hexdigest()[:16]
+
+
 @dataclass
 class PreviewVariant:
     """One creative option in a preview set."""
@@ -66,6 +100,11 @@ class PreviewSet:
     # can inspect .degradation.is_degraded to tell synthesized preview
     # topology apart from a real kernel-backed compile.
     degradation: DegradationInfo = field(default_factory=DegradationInfo)
+    # Session-identity guard — see compute_session_fingerprint(). Stamped at
+    # creation time from the session_info the creator already fetched. Empty
+    # string means "no signal" (older objects, or created without a live
+    # session) and callers must skip the staleness check.
+    session_fingerprint: str = ""
 
     def to_dict(self) -> dict:
         return {
@@ -79,4 +118,5 @@ class PreviewSet:
             "status": self.status,
             "variant_count": len(self.variants),
             "degradation": self.degradation.to_dict(),
+            "session_fingerprint": self.session_fingerprint,
         }

package/mcp_server/preview_studio/tools.py

@@ -15,6 +15,7 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import engine
+from .models import compute_session_fingerprint
 import logging
 
 logger = logging.getLogger(__name__)
@@ -114,6 +115,11 @@ def create_preview_set(
             source_kernel_id=kernel_id,
             variants=preview_variants,
             created_at_ms=now,
+            # Carry forward the fingerprint the WonderSession stamped at
+            # enter_wonder_mode time so commit_preview_variant can still
+            # detect a topology change even though this PreviewSet was
+            # built from ws.variants rather than a fresh kernel fetch.
+            session_fingerprint=getattr(ws, "session_fingerprint", ""),
         )
         engine.store_preview_set(ps)
 
@@ -286,6 +292,40 @@ async def commit_preview_variant(
             "available_variants": available,
         }
 
+    # ── Session-identity guard (state-layer hardening) ──
+    # PreviewSet.session_fingerprint is stamped at creation time from the
+    # session_info the creator already had in hand (see engine.py /
+    # create_preview_set). The compiled_plan cached on each variant carries
+    # positional track/device indices that are only valid against that same
+    # topology. If the fingerprint is set, re-check it against a fresh
+    # get_session_info before replaying those indices — a track added/
+    # removed/reordered since the preview was built means "commit" would
+    # silently apply to the wrong track. Absent fingerprint (older/degraded
+    # objects predating this field) skips the check entirely — no new
+    # round-trip, no behavior change for them.
+    if ps.session_fingerprint:
+        ableton = _get_ableton(ctx)
+        fresh_session_info: dict = {}
+        try:
+            fresh_session_info = await ableton.send_command_async("get_session_info", {}) or {}
+        except Exception as exc:
+            logger.debug("commit_preview_variant: session refresh failed: %s", exc)
+            fresh_session_info = {}
+        if isinstance(fresh_session_info, dict) and "error" not in fresh_session_info:
+            current_fingerprint = compute_session_fingerprint(fresh_session_info)
+            if current_fingerprint and current_fingerprint != ps.session_fingerprint:
+                return {
+                    "error": (
+                        "session changed since preview was created — "
+                        "rebuild the preview set"
+                    ),
+                    "code": "STATE_ERROR",
+                    "set_id": set_id,
+                    "variant_id": variant_id,
+                }
+        # else: couldn't refresh (Ableton unreachable) — fail open rather
+        # than blocking a legitimate commit on a transient fetch error.
+
     # ── Truth-gap guard: refuse to "commit" a variant that can't execute ──
     # If the variant was flagged blocked/failed upstream or lacks a
     # compiled plan, the old code still marked preview_set.status='committed'
@@ -503,7 +543,11 @@ async def render_preview_variant(
         plan = variant.compiled_plan
         steps = plan if isinstance(plan, list) else plan.get("steps", [])
 
-        from ..runtime.execution_router import execute_plan_steps_async, filter_apply_steps
+        from ..runtime.execution_router import (
+            execute_plan_steps_async,
+            filter_apply_steps,
+            undo_remote_steps,
+        )
 
         # Read-only verification steps (meters/spectrum/info) don't create undo
         # points in Ableton — counting them and then undoing walks back earlier
@@ -511,6 +555,7 @@ async def render_preview_variant(
         apply_steps = filter_apply_steps(steps)
 
         applied_count = 0
+        exec_results: list = []
         playback_started = False
         preview_mode = "metadata_only_preview"
         spectral_before: Optional[dict] = None
@@ -523,7 +568,7 @@ async def render_preview_variant(
 
         try:
             # ── 1. Capture BEFORE metadata ──
-            before_info = ableton.send_command("get_session_info", {}) or {}
+            before_info = await ableton.send_command_async("get_session_info", {}) or {}
 
             # ── 2. Apply the variant (write steps only) ──
             exec_results = await execute_plan_steps_async(
@@ -542,7 +587,7 @@ async def render_preview_variant(
                 }
 
             # ── 3. Capture AFTER metadata (variant is live) ──
-            after_info = ableton.send_command("get_session_info", {}) or {}
+            after_info = await ableton.send_command_async("get_session_info", {}) or {}
 
             # ── 4. Audible capture WHILE variant is still applied ──
             # This is the critical ordering fix: previously this block ran AFTER
@@ -558,7 +603,7 @@ async def render_preview_variant(
                     tempo = before_info.get("tempo", 120) or 120
                     play_seconds = min(bars * (60.0 / tempo) * 4, 8.0)
 
-                    ableton.send_command("start_playback", {})
+                    await ableton.send_command_async("start_playback", {})
                     playback_started = True
 
                     import asyncio as _asyncio
@@ -567,7 +612,7 @@ async def render_preview_variant(
 
                     spectral_after = cache.get_all()
 
-                    ableton.send_command("stop_playback", {})
+                    await ableton.send_command_async("stop_playback", {})
                     playback_started = False
 
                     preview_mode = "audible_preview"
@@ -582,16 +627,15 @@ async def render_preview_variant(
             # ── 5. Cleanup: stop playback if still running, then undo everything ──
             if playback_started:
                 try:
-                    ableton.send_command("stop_playback", {})
+                    await ableton.send_command_async("stop_playback", {})
                 except Exception as exc:
                     logger.debug("render_preview_variant failed: %s", exc)
 
-            for _ in range(applied_count):
-                try:
-                    ableton.send_command("undo")
-                except Exception as exc:
-                    logger.debug("render_preview_variant failed: %s", exc)
-                    break
+            # Only remote_command steps land on Ableton's linear undo stack.
+            # Bridge (M4L/OSC) and mcp_tool steps do NOT, so counting them and
+            # then issuing that many `undo`s walks back unrelated prior user
+            # edits — undo_remote_steps filters to remote_command successes.
+            await undo_remote_steps(ableton, exec_results)
 
         variant.status = "rendered"
         variant.preview_mode = preview_mode

package/mcp_server/project_brain/arrangement_graph.py

@@ -48,6 +48,10 @@ def build_arrangement_graph(
             section_type=ce_sec.section_type.value,
             energy=ce_sec.energy,
             density=ce_sec.density,
+            # Clip-presence active tracks — includes audio tracks that carry
+            # no MIDI notes. Without this, role inference would only see
+            # tracks that appear in notes_map and drop every audio track.
+            tracks_active=list(getattr(ce_sec, "tracks_active", []) or []),
         ))
 
     # Build boundary list (transitions between adjacent sections)