livepilot 1.27.1 → 1.27.3

package/mcp_server/semantic_moves/resolvers.py

@@ -124,3 +124,48 @@ def adjust_volume(current: float, delta_percent: float) -> float:
     """Adjust a volume by a percentage. delta_percent=5 means +5%."""
     new = current + (delta_percent / 100.0)
     return clamp_volume(new)
+
+
+def compile_relative_volume(
+    current: Optional[float],
+    delta_percent: float,
+    *,
+    cap: Optional[float] = None,
+    floor: Optional[float] = None,
+    fallback: float,
+) -> float:
+    """Compile a bounded RELATIVE volume nudge from a track's current level.
+
+    P2-21 fix: mix/sound-design/transition compilers used to write an
+    ABSOLUTE volume regardless of what was already on the track — e.g.
+    "make it punchier" could turn a hot drum bus DOWN by blindly writing
+    a flat 0.75. This computes current + delta_percent% instead (via
+    adjust_volume), then clamps to an optional cap/floor so the move's
+    musical intent (push toward louder / pull toward quieter) still holds
+    even when starting from an unusual level.
+
+    `current` is None when the connected Remote Script predates the
+    `volume` field in get_session_info (see transport.py get_session_info)
+    — in that case this falls back to the historical absolute value so
+    the compiler degrades gracefully instead of crashing or guessing.
+
+    The cap/floor bound the SIZE of the nudge — they must never flip its
+    DIRECTION. A track already louder than `cap` must not get pulled back
+    down to the cap when the move means to push it UP (that would
+    reintroduce the P2-21 bug in a smaller way); symmetrically a track
+    already quieter than `floor` must not get nudged back UP when the
+    move means to pull it DOWN. So after clamping to [floor, cap], the
+    result is re-clamped against `current` in the direction of travel.
+    """
+    if current is None:
+        return fallback
+    target = adjust_volume(current, delta_percent)
+    if cap is not None:
+        target = min(target, cap)
+    if floor is not None:
+        target = max(target, floor)
+    if delta_percent > 0:
+        target = max(target, current)
+    elif delta_percent < 0:
+        target = min(target, current)
+    return clamp_volume(target)

package/mcp_server/semantic_moves/sound_design_compilers.py

@@ -33,11 +33,15 @@ def _compile_add_warmth(move: SemanticMove, kernel: dict) -> CompiledPlan:
         idx = t["index"]
         name = t["name"]
 
-        # Boost volume slightly for perceived warmth
+        # Boost volume slightly for perceived warmth — RELATIVE nudge
+        # (P2-21), capped so an already-hot track isn't pushed toward clip.
+        target = resolvers.compile_relative_volume(
+            t.get("volume"), 6, cap=0.80, fallback=0.65
+        )
         steps.append(CompiledStep(
             tool="set_track_volume",
-            params={"track_index": idx, "volume": 0.65},
-            description=f"Boost {name} slightly for warmth",
+            params={"track_index": idx, "volume": target},
+            description=f"Boost {name} to {target:.2f} for warmth",
         ))
 
         # Add reverb send for depth/warmth perception
@@ -138,11 +142,15 @@ def _compile_shape_transients(move: SemanticMove, kernel: dict) -> CompiledPlan:
         idx = dt["index"]
         name = dt["name"]
 
-        # Push volume for transient punch
+        # Push volume for transient punch — RELATIVE nudge (P2-21), capped
+        # so an already-hot drum bus isn't pushed toward clip.
+        target = resolvers.compile_relative_volume(
+            dt.get("volume"), 8, cap=0.85, fallback=0.75
+        )
         steps.append(CompiledStep(
             tool="set_track_volume",
-            params={"track_index": idx, "volume": 0.75},
-            description=f"Push {name} to 0.75 for transient punch",
+            params={"track_index": idx, "volume": target},
+            description=f"Push {name} to {target:.2f} for transient punch",
         ))
         descriptions.append(f"Push {name} for punch")
 

package/mcp_server/semantic_moves/tools.py

@@ -8,6 +8,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from typing import Optional
 
 from fastmcp import Context
@@ -323,7 +324,7 @@ async def apply_semantic_move(
 
     # Build a lightweight kernel from session info
     ableton = ctx.lifespan_context["ableton"]
-    session_info = ableton.send_command("get_session_info")
+    session_info = await asyncio.to_thread(ableton.send_command, "get_session_info")
     kernel = {
         "session_info": session_info,
         "mode": mode,
@@ -394,7 +395,77 @@ async def apply_semantic_move(
             "ok": er.ok,
         })
 
-    success_count = sum(1 for s in executed_steps if s["ok"])
+    # ── Verify-after playback guard ──────────────────────────────────────────
+    # get_track_meters returns is_playing=False + all-zero values when the
+    # transport is stopped. Counting such a step as "ok" inflates success_count
+    # with meaningless verification signal. Detect this pattern and annotate
+    # affected steps as verification_skipped so the caller knows the result
+    # cannot confirm that the move had the intended audible effect.
+    #
+    # Detection heuristic: step tool is get_track_meters or get_master_meters
+    # AND the returned result contains is_playing=False (or is_playing absent
+    # and all numeric meter values are exactly 0.0). We do not modify ok=True
+    # (the tool call itself succeeded) — we add a side-channel flag.
+    _METER_VERIFY_TOOLS = {"get_track_meters", "get_master_meters"}
+    meter_verify_skipped_count = 0
+    for es in executed_steps:
+        if es["tool"] not in _METER_VERIFY_TOOLS:
+            continue
+        if not es["ok"] or es["result"] is None:
+            continue
+        result_data = es["result"]
+        if not isinstance(result_data, dict):
+            continue
+        # is_playing key present and explicitly False → stopped transport.
+        # NOTE: the meter verify steps run through the remote_command path,
+        # whose handler returns the BARE meter shape with NO is_playing key
+        # (the MCP-wrapper that annotates is_playing is bypassed here). So we
+        # ALSO apply the all-zero-meters fallback when is_playing is absent.
+        is_playing_flag = result_data.get("is_playing")
+        skip = False
+        note = ""
+        if is_playing_flag is False:
+            skip = True
+            note = (
+                "Playback was stopped — meter values are zero; "
+                "verification deferred until transport is running"
+            )
+        elif is_playing_flag is None:
+            # Collect every present numeric meter value (track shape or
+            # single-track/master shape). If there IS at least one and they
+            # are ALL exactly 0.0, the transport is almost certainly stopped
+            # → unverifiable. Guard against an empty tracks list so "no
+            # tracks" is not mistaken for "stopped".
+            meter_vals = []
+            tracks = result_data.get("tracks")
+            if isinstance(tracks, list) and tracks:
+                for t in tracks:
+                    if isinstance(t, dict):
+                        for k in ("level", "left", "right"):
+                            v = t.get(k)
+                            if isinstance(v, (int, float)):
+                                meter_vals.append(v)
+            else:
+                for k in ("level", "left", "right"):
+                    v = result_data.get(k)
+                    if isinstance(v, (int, float)):
+                        meter_vals.append(v)
+            if meter_vals and all(v == 0.0 for v in meter_vals):
+                skip = True
+                note = (
+                    "Meters all zero (transport likely stopped) — "
+                    "verification deferred until audio is playing"
+                )
+        if skip:
+            es["verification_skipped"] = True
+            es["verification_note"] = note
+            meter_verify_skipped_count += 1
+
+    # success_count: tool calls that succeeded AND are NOT skipped verify steps
+    success_count = sum(
+        1 for s in executed_steps
+        if s["ok"] and not s.get("verification_skipped", False)
+    )
     failure_count = sum(1 for s in executed_steps if not s["ok"])
 
     # store_purpose: writer
@@ -437,6 +508,13 @@ async def apply_semantic_move(
     result["execution_results"] = executed_steps
     result["success_count"] = success_count
     result["failure_count"] = failure_count
+    if meter_verify_skipped_count > 0:
+        result["verification_note"] = (
+            f"{meter_verify_skipped_count} meter verification step(s) skipped: "
+            "playback was stopped when meters were read — start transport before "
+            "re-running this move to get meaningful before/after confirmation"
+        )
+        result["verification_skipped_count"] = meter_verify_skipped_count
     if ledger_entry_id is not None:
         result["ledger_entry_id"] = ledger_entry_id
     return result

package/mcp_server/semantic_moves/transition_compilers.py

@@ -23,10 +23,15 @@ def _compile_increase_forward_motion(move: SemanticMove, kernel: dict) -> Compil
     drums = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
 
     for dt in drums[:1]:
+        # RELATIVE nudge (P2-21), capped so an already-hot drum bus isn't
+        # pushed toward clip.
+        target = resolvers.compile_relative_volume(
+            dt.get("volume"), 8, cap=0.85, fallback=0.75
+        )
         steps.append(CompiledStep(
             tool="set_track_volume",
-            params={"track_index": dt["index"], "volume": 0.75},
-            description=f"Push {dt['name']} to 0.75 for forward drive",
+            params={"track_index": dt["index"], "volume": target},
+            description=f"Push {dt['name']} to {target:.2f} for forward drive",
         ))
         descriptions.append(f"Push {dt['name']} forward")
 
@@ -66,12 +71,16 @@ def _compile_open_chorus(move: SemanticMove, kernel: dict) -> CompiledPlan:
     melodic = resolvers.find_tracks_by_role(kernel, ["chords", "lead", "pad"])
     drums = resolvers.find_tracks_by_role(kernel, ["drums"])
 
-    # Push all melodic tracks
+    # Push all melodic tracks — RELATIVE nudge (P2-21), capped so an
+    # already-hot track isn't pushed toward clip.
     for mt in melodic:
+        target = resolvers.compile_relative_volume(
+            mt.get("volume"), 8, cap=0.85, fallback=0.75
+        )
         steps.append(CompiledStep(
             tool="set_track_volume",
-            params={"track_index": mt["index"], "volume": 0.75},
-            description=f"Push {mt['name']} to 0.75 for chorus energy",
+            params={"track_index": mt["index"], "volume": target},
+            description=f"Push {mt['name']} to {target:.2f} for chorus energy",
         ))
         descriptions.append(f"Push {mt['name']}")
 
@@ -126,18 +135,26 @@ def _compile_create_breakdown(move: SemanticMove, kernel: dict) -> CompiledPlan:
     pads = resolvers.find_tracks_by_role(kernel, ["pad"])
 
     for dt in drums:
+        # RELATIVE nudge (P2-21), floored so an already-quiet drum bus
+        # doesn't get pulled to silence.
+        target = resolvers.compile_relative_volume(
+            dt.get("volume"), -15, floor=0.15, fallback=0.25
+        )
         steps.append(CompiledStep(
             tool="set_track_volume",
-            params={"track_index": dt["index"], "volume": 0.25},
-            description=f"Strip {dt['name']} to 0.25 for breakdown",
+            params={"track_index": dt["index"], "volume": target},
+            description=f"Strip {dt['name']} to {target:.2f} for breakdown",
         ))
         descriptions.append(f"Strip {dt['name']}")
 
     for bt in bass[:1]:
+        target = resolvers.compile_relative_volume(
+            bt.get("volume"), -12, floor=0.20, fallback=0.30
+        )
         steps.append(CompiledStep(
             tool="set_track_volume",
-            params={"track_index": bt["index"], "volume": 0.30},
-            description=f"Reduce {bt['name']} to 0.30",
+            params={"track_index": bt["index"], "volume": target},
+            description=f"Reduce {bt['name']} to {target:.2f}",
         ))
         descriptions.append(f"Reduce {bt['name']}")
 

package/mcp_server/server.py

@@ -10,6 +10,7 @@ from fastmcp import FastMCP, Context  # noqa: F401
 
 from .connection import AbletonConnection
 from .m4l_bridge import SpectralCache, SpectralReceiver, M4LBridge, MidiToolCache
+from .persistence.taste_store import PersistentTasteStore
 
 # Logger must be defined before any function uses it — several module-level
 # helpers below (e.g. _master_has_livepilot_analyzer) call logger.debug on
@@ -133,7 +134,9 @@ async def _warm_analyzer_bridge(
     timeout: float = 3.0,
 ) -> None:
     """Give the analyzer stream a short startup window before first use."""
-    if not _master_has_livepilot_analyzer(ableton):
+    # _master_has_livepilot_analyzer does a blocking TCP round-trip — run it
+    # off the event-loop thread so a slow Ableton can't stall startup.
+    if not await asyncio.to_thread(_master_has_livepilot_analyzer, ableton):
         return
 
     loop = asyncio.get_running_loop()
@@ -202,7 +205,10 @@ async def lifespan(server):
         # Degrade gracefully. The reconnect_bridge tool can retry later
         # if the other instance is stopped.
         import sys
-        holder_info = _identify_port_holder(9880)
+        # _identify_port_holder runs two blocking subprocess.check_output
+        # calls (lsof + ps) — offload so a slow/busy host can't stall the
+        # event loop during startup, same as the neighboring lifespan calls.
+        holder_info = await asyncio.to_thread(_identify_port_holder, 9880)
         print(
             "LivePilot: UDP port 9880 already in use%s — "
             "analyzer/bridge tools unavailable at startup. "
@@ -223,7 +229,7 @@ async def lifespan(server):
     try:
         # BUG-A1: detect stale Remote Script installs early so the user
         # sees a clear message instead of cryptic "Unknown command type" errors.
-        _check_remote_script_version(ableton)
+        await asyncio.to_thread(_check_remote_script_version, ableton)
         if bridge_state["transport"] is not None:
             await _warm_analyzer_bridge(ableton, spectral)
         # Bind per-project persistent store so creative threads and turn
@@ -231,7 +237,7 @@ async def lifespan(server):
         # through the tracker but never called — threads/turns were effectively
         # in-memory only. If Ableton isn't reachable yet, tools will lazy-bind
         # on first write via ensure_project_store_bound().
-        _bind_session_continuity(ableton)
+        await asyncio.to_thread(_bind_session_continuity, ableton)
         yield {
             "ableton": ableton,
             "spectral": spectral,
@@ -240,6 +246,12 @@ async def lifespan(server):
             "_bridge_state": bridge_state,
             "mcp_dispatch": mcp_dispatch,
             "splice_client": splice_client,
+            # Persistent taste backing so dimension weights / anti-preferences
+            # survive a server restart (P2-29). Keyed "persistent_taste" to match
+            # the existing wonder/runtime/preview_studio setdefault callers so all
+            # tools share ONE instance. Only present on the live server; tests
+            # construct their own context without it → session-only taste.
+            "persistent_taste": PersistentTasteStore(),
         }
     finally:
         if bridge_state["transport"]:
@@ -362,7 +374,7 @@ def _get_all_tools():
     to the next path rather than exploding.
 
     WARNING: Accesses FastMCP private internals. Pinned to
-    fastmcp>=3.3.1,<3.4.0 in requirements.txt. The startup self-test
+    fastmcp>=3.4.2,<3.5.0 in requirements.txt. The startup self-test
     (_assert_tool_registry_accessible) will fail loudly if every probe
     returns empty — better than silently returning [] and disabling
     schema coercion.
@@ -521,32 +533,22 @@ _patch_tool_schemas()
 
 
 # ─────────────────────────────────────────────────────────────────────────
-# v1.23.0: User-local atlas overlay boot hook.
+# v1.23.0: User-local atlas overlay loading.
 #
-# Loads YAMLs from ~/.livepilot/atlas-overlays/<namespace>/ into the
+# YAMLs from ~/.livepilot/atlas-overlays/<namespace>/ are loaded into the
 # module-level OverlayIndex singleton. The 3 extension_atlas_* tools
 # registered above resolve the singleton at REQUEST time (via the
-# get_overlay_index() accessor), so this load can happen after their
-# registration without ordering issues.
+# get_overlay_index() accessor).
 #
-# Failures are logged but never abort boot — server starts even if the
-# user has no overlays installed or has malformed YAMLs.
+# v1.27.3 perf batch: population moved from an unconditional import-time
+# call here (measured ~1.1s of a ~2s import with a populated overlay tree)
+# to lazy first-access population inside get_overlay_index() itself (see
+# _ensure_loaded() in mcp_server/atlas/overlays.py, guarded by a lock).
+# Nothing in this codebase depends on the singleton being populated at
+# import time — every caller resolves it via get_overlay_index() at request
+# time — so this boot hook is no longer needed.
 # Spec: docs/superpowers/specs/2026-04-25-user-local-extensions-design.md §6.1
 # ─────────────────────────────────────────────────────────────────────────
-try:
-    from .atlas.overlays import load_overlays
-    _overlay_idx_at_boot = load_overlays()
-    _overlay_count = len(_overlay_idx_at_boot.all_entries())
-    if _overlay_count:
-        logger.info(
-            f"User-local overlays loaded: {_overlay_count} entries across "
-            f"namespaces {_overlay_idx_at_boot.list_namespaces()}"
-        )
-    else:
-        logger.debug("User-local overlays: none installed at "
-                     "~/.livepilot/atlas-overlays/")
-except Exception as e:
-    logger.warning(f"User-local overlay load failed (non-fatal, server continues): {e}")
 
 
 def main():

package/mcp_server/session_continuity/tracker.py

@@ -97,20 +97,68 @@ def bind_project_store_from_session(session_info: dict) -> Optional[str]:
         logger.debug("bind_project_store_from_session: read failed: %s", exc)
         raw_threads, raw_turns = [], []
 
-    _threads = {
+    # MERGE, don't overwrite. The whole reason a lazy/late bind exists is the
+    # startup bind couldn't reach Ableton — during that window the tracker
+    # accepted open_thread()/record_turn_resolution() with no store attached,
+    # so those entries live ONLY in _threads/_turns and were never flushed. A
+    # naive reassignment of _threads/_turns from disk silently discards them
+    # (data loss). Instead: disk is the truth for anything it already holds
+    # (id-keyed), and any in-memory entry whose id is absent on disk is an
+    # unpersisted survivor we keep AND flush so the next bind sees it on disk.
+    disk_threads = {
         t["thread_id"]: CreativeThread.from_dict(t)
         for t in raw_threads
         if isinstance(t, dict) and "thread_id" in t
     }
-    _turns = [
+    unflushed_threads = [
+        thread for tid, thread in _threads.items()
+        if tid and tid not in disk_threads
+    ]
+    merged_threads = dict(disk_threads)
+    for thread in unflushed_threads:
+        merged_threads[thread.thread_id] = thread
+
+    disk_turn_ids = {
+        t["turn_id"] for t in raw_turns
+        if isinstance(t, dict) and t.get("turn_id")
+    }
+    disk_turns = [
         TurnResolution.from_dict(t)
         for t in raw_turns
         if isinstance(t, dict)
     ]
+    # Turns are append-only history: keep disk order, then append any
+    # in-memory turn whose id isn't already on disk (preserve insertion order).
+    unflushed_turns = [
+        turn for turn in _turns
+        if turn.turn_id and turn.turn_id not in disk_turn_ids
+    ]
+    merged_turns = disk_turns + unflushed_turns
+
+    _threads = merged_threads
+    _turns = merged_turns
     _project_store = store
+
+    # Persist the survivors now that a store is attached. We do this AFTER
+    # binding _project_store so a failure here doesn't leave the survivors
+    # invisible — they're already live in memory; this only writes them
+    # through to disk so a future restart/rebind keeps them.
+    for thread in unflushed_threads:
+        try:
+            store.save_thread(thread.to_dict())
+        except Exception as exc:
+            logger.debug("bind_project_store_from_session: thread flush failed: %s", exc)
+    for turn in unflushed_turns:
+        try:
+            store.save_turn(turn.to_dict())
+        except Exception as exc:
+            logger.debug("bind_project_store_from_session: turn flush failed: %s", exc)
+
     logger.info(
-        "session_continuity: bound project %s (%d threads, %d turns restored)",
+        "session_continuity: bound project %s "
+        "(%d threads, %d turns; %d threads + %d turns merged from memory)",
         new_id, len(_threads), len(_turns),
+        len(unflushed_threads), len(unflushed_turns),
     )
     return new_id
 

package/mcp_server/song_brain/builder.py

@@ -46,7 +46,6 @@ def build_song_brain(
     role_graph = role_graph or {}
     recent_moves = recent_moves or []
 
-    brain_id = _compute_brain_id(session_info, scenes)
     built_from: dict[str, bool] = {
         "session_info": True,
         "scenes": bool(scenes),
@@ -74,6 +73,13 @@ def build_song_brain(
 
     drift_risk = _estimate_drift_risk(recent_moves, sacred)
 
+    # Content-aware brain_id: computed AFTER identity_core/sections/energy_arc
+    # so it reflects actual musical content, not just track/scene counts.
+    # See _compute_brain_id docstring.
+    brain_id = _compute_brain_id(
+        session_info, scenes, identity_core, energy_arc, sections
+    )
+
     # Evidence-weighted confidence adjustment
     # Weights: motif=0.4, composition=0.2, role_graph=0.15, scenes=0.15, recent_moves=0.1
     evidence_weights = {
@@ -343,7 +349,7 @@ def _infer_section_purposes(
     # From composition analysis if available
     comp_sections = composition.get("sections", [])
     if comp_sections:
-        for sec in comp_sections:
+        for i, sec in enumerate(comp_sections):
             name = str(sec.get("name", ""))
             # BUG-B12: skip empty placeholder sections that pollute the
             # energy_arc and section_purposes list. A section with no name
@@ -360,7 +366,11 @@ def _infer_section_purposes(
                 or intent.lower() in _PAYOFF_INTENTS
             )
             sections.append(SectionPurpose(
-                section_id=sec.get("id", name),
+                # Must be UNIQUE: _build_energy_arc / detect_identity_drift key
+                # before/after energy by section_id. A section with energy>0 but
+                # no "id" and an empty name would yield "" for two distinct
+                # sections, collapsing them in the dict and dropping one's drift.
+                section_id=sec.get("id") or name.strip() or f"section_{i}",
                 label=sec.get("label", name),
                 emotional_intent=intent,
                 energy_level=sec.get("energy", 0.5),
@@ -608,11 +618,43 @@ def detect_identity_drift(
 # ── Helpers ───────────────────────────────────────────────────────
 
 
-def _compute_brain_id(session_info: dict, scenes: list[dict]) -> str:
-    """Deterministic brain ID from session state."""
+def _compute_brain_id(
+    session_info: dict,
+    scenes: list[dict],
+    identity_core: str = "",
+    energy_arc: Optional[list[float]] = None,
+    section_purposes: Optional[list[SectionPurpose]] = None,
+) -> str:
+    """Deterministic brain ID from session state AND musical content.
+
+    Previously hashed only {tempo, track_count, scene_count}. A note-only
+    edit (same track/scene counts, different melodic/harmonic/energy
+    content) produced the SAME brain_id every time. detect_identity_drift
+    keys its snapshot store by brain_id (song_brain/tools.py
+    _brain_snapshots), so an unchanged id meant every "after" build silently
+    overwrote its own "before" baseline in that dict and drift always read
+    0.0 even when the song's actual identity had shifted.
+
+    Folding identity_core / energy_arc / section signatures in keeps the id
+    STABLE across identical builds (same inputs -> same id — still a pure,
+    deterministic function) while making it change whenever the song's
+    inferred content changes, even when track/scene counts don't.
+    """
+    section_sig = [
+        {
+            "section_id": s.section_id,
+            "energy_level": round(s.energy_level, 3),
+            "emotional_intent": s.emotional_intent,
+            "is_payoff": s.is_payoff,
+        }
+        for s in (section_purposes or [])
+    ]
     seed = json.dumps({
         "tempo": session_info.get("tempo"),
         "track_count": session_info.get("track_count"),
         "scene_count": len(scenes),
+        "identity_core": identity_core,
+        "energy_arc": [round(e, 3) for e in (energy_arc or [])],
+        "section_purposes": section_sig,
     }, sort_keys=True)
     return hashlib.sha256(seed.encode()).hexdigest()[:12]

package/mcp_server/song_brain/tools.py

@@ -7,6 +7,8 @@
 
 from __future__ import annotations
 
+import threading
+
 from fastmcp import Context
 
 from ..runtime.degradation import DegradationInfo
@@ -24,6 +26,10 @@ _current_brain: SongBrain | None = None
 # Snapshot store: brain_id -> SongBrain, max 10 snapshots
 _brain_snapshots: dict[str, SongBrain] = {}
 _MAX_SNAPSHOTS = 10
+# Guards _brain_snapshots store/evict — the MCP server can service concurrent
+# tool calls, and store-then-evict was a read-modify-write on a shared dict
+# with no synchronization (same race shape flagged in the persistence stores).
+_snapshots_lock = threading.Lock()
 
 
 def _set_brain(ctx: Context, brain: SongBrain) -> None:
@@ -32,16 +38,24 @@ def _set_brain(ctx: Context, brain: SongBrain) -> None:
     _current_brain = brain
     ctx.lifespan_context["current_brain"] = brain
     # Save snapshot for later drift comparison
-    _brain_snapshots[brain.brain_id] = brain
-    # Evict oldest if over limit
-    while len(_brain_snapshots) > _MAX_SNAPSHOTS:
-        oldest_key = next(iter(_brain_snapshots))
-        del _brain_snapshots[oldest_key]
+    with _snapshots_lock:
+        _brain_snapshots[brain.brain_id] = brain
+        # Evict oldest if over limit
+        while len(_brain_snapshots) > _MAX_SNAPSHOTS:
+            oldest_key = next(iter(_brain_snapshots))
+            del _brain_snapshots[oldest_key]
 
 
 def _get_snapshot(brain_id: str) -> SongBrain | None:
     """Retrieve a past brain snapshot by ID."""
-    return _brain_snapshots.get(brain_id)
+    with _snapshots_lock:
+        return _brain_snapshots.get(brain_id)
+
+
+def _snapshot_ids() -> list[str]:
+    """List currently held snapshot ids (lock-guarded snapshot for error reporting)."""
+    with _snapshots_lock:
+        return list(_brain_snapshots.keys())
 
 
 def _get_ableton(ctx: Context):
@@ -371,7 +385,7 @@ def detect_identity_drift(
     if before_brain_id:
         before = _get_snapshot(before_brain_id)
         if before is None:
-            available = list(_brain_snapshots.keys())
+            available = _snapshot_ids()
             return {
                 "error": f"No snapshot found for brain_id '{before_brain_id}'",
                 "available_snapshots": available,

package/mcp_server/sound_design/critics.py

@@ -7,6 +7,7 @@ All pure computation, zero I/O.
 
 from __future__ import annotations
 
+import re
 from dataclasses import asdict, dataclass, field
 
 from .models import (