livepilot 1.9.15 → 1.9.16

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "livepilot",
       "description": "Agentic production system for Ableton Live 12 — 236 tools, 32 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
-      "version": "1.9.15",
+      "version": "1.9.16",
       "author": {
         "name": "Pilot Studio"
       },

package/AGENTS.md

@@ -1,4 +1,4 @@
-# LivePilot v1.9.14 — Ableton Live 12
+# LivePilot v1.9.16 — Ableton Live 12
 
 ## Project
 - **Repo:** This directory (LivePilot)

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # Changelog
 
+## 1.9.16 — Comprehensive Bug Fix Audit (April 2026)
+
+### Critical Fixes
+- **connection.py** — Don't retry TCP commands after timeout (prevents duplicate mutations in Ableton)
+- **connection.py** — Add `send_command_async()` to avoid blocking the asyncio event loop
+- **technique_store.py** — Thread-safe initialization with double-checked locking; add missing `_ensure_initialized()` in `increment_replay`
+- **capability_state.py** — Fix inverted mode logic: offline analyzer is now correctly more restrictive than stale analyzer
+- **server.py** — Fix thread safety: assign `_client_thread` inside lock
+- **action_ledger_models.py** — Thread-safe unique IDs with UUID session suffix
+
+### High-Priority Fixes
+- **notes.py / arrangement.py** — `modify_notes` now applies `mute`, `velocity_deviation`, `release_velocity` (previously silently dropped)
+- **clips.py** — `create_clip` checks `has_clip` first; `set_clip_loop` uses conditional ordering for shrink vs expand
+- **notes.py / arrangement.py** — Fix `transpose_notes` default `time_span` when `from_time > 0`
+- **m4l_bridge.py** — Clear stale response future after timeout
+- **composition.py** — Fix `get_phrase_grid` using section_index as clip_index
+- **devices.py** — Fix `_postflight_loaded_device` always reporting plugins as failed
+- **tracks.py** — Correct input monitoring enum (0=Off, 1=In, 2=Auto); fix `set_group_fold` allowing return tracks
+- **research.py** — Fix browser path casing (`"Instruments"` → `"instruments"`)
+- **midi_io.py** — Fix path traversal check prefix collision
+- **fabric.py** — Distinguish `measured` vs `measured_reject` decision modes
+- **critics.py** — Fix dynamics critic double-counting `over_compressed` + `flat_dynamics`
+- **refresh.py** — Deep-copy freshness objects to prevent mutation leak
+- **mix_engine/tools.py** — Fix `track_count` key (always 0) → use `len(tracks)`
+- **safety.py** — Distinguish `unknown` from `caution` for unrecognized move types
+- **translation_engine** — Fix pan values always 0 (check nested `mixer.panning`)
+- **livepilot_bridge.js** — Track selection by LiveAPI ID (not name); 4-byte UTF-8 support (emoji)
+
+### Medium Fixes
+- Version strings bumped across all files
+- `hashlib.md5` calls use `usedforsecurity=False` (FIPS compat)
+- `.mcp.json` uses portable `node` command
+- README "32 additional tools" → "29"
+- Lazy `asyncio.Lock` creation in M4L bridge
+- `_friendly_error` now includes `command_type` in output
+
+### Test Improvements
+- Tests updated to match corrected capability_state, dynamics critic, and safety logic
+- `test_default_name_detection` now imports production function instead of local copy
+
 ## 1.9.15 — V2 Engine Architecture (April 2026)
 
 ### New Engine Packages (12)

package/README.md

@@ -448,7 +448,7 @@ Windsurf — `~/.codeium/windsurf/mcp_config.json`:
 
 Drag `LivePilot_Analyzer.amxd` onto the master track.
 
-Unlocks 32 additional tools: spectral analysis, key detection,
+Unlocks 29 additional tools: spectral analysis, key detection,
 sample manipulation, deep device introspection, plugin parameter mapping.
 
 > [!IMPORTANT]

package/livepilot/.Codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.15",
+  "version": "1.9.16",
   "description": "Agentic production system for Ableton Live 12 — 236 tools, 32 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": {
     "name": "Pilot Studio"

package/livepilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.15",
+  "version": "1.9.16",
   "description": "Agentic production system for Ableton Live 12 — 236 tools, 32 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": {
     "name": "Pilot Studio"

package/livepilot/skills/livepilot-core/references/overview.md

@@ -1,4 +1,4 @@
-# LivePilot v1.9.14 — Architecture & Tool Reference
+# LivePilot v1.9.16 — Architecture & Tool Reference
 
 Agentic production system for Ableton Live 12. 236 tools across 32 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift, additive process), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O.
 

package/m4l_device/livepilot_bridge.js

@@ -84,7 +84,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.9.14"});
+            send_response({"ok": true, "version": "1.9.16"});
             break;
         case "get_params":
             cmd_get_params(args);
@@ -513,16 +513,17 @@ function cmd_get_selected() {
         appointed_device: null
     };
 
-    // Selected track
+    // Selected track — match by object ID (not name, which can be duplicated)
     try {
         cursor_b.goto("live_set view selected_track");
         result.selected_track_name = cursor_b.get("name").toString();
-        // Get track index by walking tracks
+        var selected_id = cursor_b.id;
+        // Get track index by walking tracks and comparing IDs
         cursor_a.goto("live_set");
         var tc = cursor_a.getcount("tracks");
         for (var i = 0; i < tc; i++) {
             cursor_a.goto("live_set tracks " + i);
-            if (cursor_a.get("name").toString() === result.selected_track_name) {
+            if (cursor_a.id === selected_id) {
                 result.selected_track = i;
                 break;
             }
@@ -533,7 +534,7 @@ function cmd_get_selected() {
             var rtc = cursor_a.getcount("return_tracks");
             for (var j = 0; j < rtc; j++) {
                 cursor_a.goto("live_set return_tracks " + j);
-                if (cursor_a.get("name").toString() === result.selected_track_name) {
+                if (cursor_a.id === selected_id) {
                     result.selected_track = -(j + 1);  // -1, -2, ... convention
                     break;
                 }
@@ -542,7 +543,7 @@ function cmd_get_selected() {
         // Check master track if still not found
         if (result.selected_track === -1) {
             cursor_a.goto("live_set master_track");
-            if (cursor_a.get("name").toString() === result.selected_track_name) {
+            if (cursor_a.id === selected_id) {
                 result.selected_track = -1000;  // master convention
             }
         }
@@ -743,7 +744,7 @@ function base64_decode(str) {
 
 function _utf8_decode(bytes) {
     // Convert a UTF-8 byte array back to a JavaScript string.
-    // Handles BMP codepoints which covers the text LivePilot exchanges.
+    // Handles BMP codepoints and 4-byte sequences (emoji/supplementary planes).
     var result = "";
     for (var i = 0; i < bytes.length;) {
         var b0 = bytes[i];
@@ -754,17 +755,30 @@ function _utf8_decode(bytes) {
             var b1 = bytes[i + 1];
             result += String.fromCharCode(((b0 & 0x1F) << 6) | (b1 & 0x3F));
             i += 2;
-        } else if (i + 2 < bytes.length) {
-            var b2 = bytes[i + 1];
-            var b3 = bytes[i + 2];
+        } else if ((b0 & 0xF0) === 0xE0 && i + 2 < bytes.length) {
+            // 3-byte sequence (U+0800..U+FFFF)
+            var b1_3 = bytes[i + 1];
+            var b2_3 = bytes[i + 2];
             result += String.fromCharCode(
                 ((b0 & 0x0F) << 12) |
-                ((b2 & 0x3F) << 6) |
-                (b3 & 0x3F)
+                ((b1_3 & 0x3F) << 6) |
+                (b2_3 & 0x3F)
             );
             i += 3;
+        } else if ((b0 & 0xF8) === 0xF0 && i + 3 < bytes.length) {
+            // 4-byte sequence (U+10000..U+10FFFF) — emoji and supplementary planes
+            var cp = ((b0 & 0x07) << 18) |
+                     ((bytes[i + 1] & 0x3F) << 12) |
+                     ((bytes[i + 2] & 0x3F) << 6) |
+                     (bytes[i + 3] & 0x3F);
+            // Encode as UTF-16 surrogate pair
+            cp -= 0x10000;
+            result += String.fromCharCode(0xD800 + (cp >> 10));
+            result += String.fromCharCode(0xDC00 + (cp & 0x3FF));
+            i += 4;
         } else {
-            break;
+            // Skip invalid byte
+            i += 1;
         }
     }
     return result;

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.9.14"
+__version__ = "1.9.16"

package/mcp_server/connection.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 import socket
@@ -40,6 +41,8 @@ def _friendly_error(code: str, message: str, command_type: str) -> str:
     """Format an error from the Remote Script into a user-friendly message."""
     hint = _ERROR_HINTS.get(code, "")
     parts = [f"[{code}] {message}"]
+    if command_type:
+        parts.append(f"(while running '{command_type}')")
     if hint:
         parts.append(hint)
     return " ".join(parts)
@@ -143,7 +146,9 @@ class AbletonConnection:
 
         Thread-safe: a lock serializes all TCP send/receive cycles to
         prevent socket corruption when multiple MCP tools fire concurrently.
-        Retries once on socket errors with a fresh connection.
+        Retries once on connection errors (command never reached Ableton).
+        Does NOT retry on timeouts — Ableton may have already processed the
+        command, and retrying would cause duplicate mutations.
         """
         with self._lock:
             # Ensure we have a connection
@@ -156,7 +161,15 @@ class AbletonConnection:
 
             try:
                 response = self._send_raw(command)
-            except (OSError, AbletonConnectionError):
+            except AbletonConnectionError as exc:
+                # Don't retry timeouts — Ableton may have processed the command
+                if "Timeout" in str(exc):
+                    raise
+                # Retry once with a fresh connection for non-timeout errors
+                self.disconnect()
+                self.connect()
+                response = self._send_raw(command)
+            except OSError:
                 # Retry once with a fresh connection
                 self.disconnect()
                 self.connect()
@@ -183,6 +196,15 @@ class AbletonConnection:
         self._command_log.append(log_entry)
         return response.get("result", {})
 
+    async def send_command_async(self, command_type: str, params: Optional[dict] = None) -> dict:
+        """Async wrapper around send_command that avoids blocking the event loop.
+
+        Runs the blocking TCP send/receive in a thread pool executor so the
+        asyncio event loop remains responsive to other concurrent MCP tools.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, self.send_command, command_type, params)
+
     # ------------------------------------------------------------------
     # Command log
     # ------------------------------------------------------------------

package/mcp_server/curves.py

@@ -314,7 +314,7 @@ def _perlin(duration: float, density: int, center: float = 0.5,
 
     def _hash_float(x: float, s: float) -> float:
         """Deterministic pseudo-random float from position + seed."""
-        h = hashlib.md5(f"{x:.6f}:{s:.6f}".encode()).hexdigest()
+        h = hashlib.md5(f"{x:.6f}:{s:.6f}".encode(), usedforsecurity=False).hexdigest()
         return (int(h[:8], 16) / 0xFFFFFFFF) * 2.0 - 1.0
 
     def _smoothstep(t: float) -> float:
@@ -363,7 +363,7 @@ def _brownian(duration: float, density: int, start: float = 0.5,
     import hashlib
 
     def _det_random(i: int, s: float) -> float:
-        h = hashlib.md5(f"{i}:{s:.6f}".encode()).hexdigest()
+        h = hashlib.md5(f"{i}:{s:.6f}".encode(), usedforsecurity=False).hexdigest()
         return (int(h[:8], 16) / 0xFFFFFFFF) * 2.0 - 1.0
 
     points = []
@@ -589,7 +589,7 @@ def _stochastic(duration: float, density: int, center: float = 0.5,
     import hashlib
 
     def _det_random(i: int, s: float) -> float:
-        h = hashlib.md5(f"{i}:{s:.6f}".encode()).hexdigest()
+        h = hashlib.md5(f"{i}:{s:.6f}".encode(), usedforsecurity=False).hexdigest()
         return (int(h[:8], 16) / 0xFFFFFFFF) * 2.0 - 1.0
 
     points = []

package/mcp_server/evaluation/fabric.py

@@ -136,7 +136,7 @@ def evaluate_sonic_move(
     elif keep_change:
         decision_mode = "measured"
     else:
-        decision_mode = "measured"
+        decision_mode = "measured_reject"
 
     return EvaluationResult(
         engine=request.engine or "sonic",

package/mcp_server/m4l_bridge.py

@@ -338,13 +338,15 @@ class M4LBridge:
         self.receiver = receiver
         self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         self._m4l_addr = ("127.0.0.1", 9881)
-        self._cmd_lock = asyncio.Lock()
+        self._cmd_lock: Optional[asyncio.Lock] = None
 
     async def send_command(self, command: str, *args: Any, timeout: float = 5.0) -> dict:
         """Send an OSC command to the M4L device and wait for the response."""
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        if self._cmd_lock is None:
+            self._cmd_lock = asyncio.Lock()
         async with self._cmd_lock:
             # Create a future for the response
             loop = asyncio.get_running_loop()
@@ -362,6 +364,10 @@ class M4LBridge:
                 result = await asyncio.wait_for(future, timeout=timeout)
                 return result
             except asyncio.TimeoutError:
+                # Clear the stale future so a delayed response doesn't resolve
+                # a future that no caller is waiting on
+                if self.receiver:
+                    self.receiver.set_response_future(None)
                 return {"error": "M4L bridge timeout — device may be busy or removed"}
 
     async def send_capture(self, command: str, *args: Any, timeout: float = 35.0) -> dict:
@@ -369,6 +375,8 @@ class M4LBridge:
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        if self._cmd_lock is None:
+            self._cmd_lock = asyncio.Lock()
         async with self._cmd_lock:
             # Cancel any stale capture future before creating a new one
             if self.receiver and self.receiver._capture_future and not self.receiver._capture_future.done():

package/mcp_server/memory/technique_store.py

@@ -37,28 +37,35 @@ class TechniqueStore:
 
         Deferred so that a read-only HOME doesn't crash the entire MCP
         server at import time — memory tools just return errors instead.
+        Thread-safe: uses double-checked locking to prevent concurrent
+        callers from racing on initialization.
         """
         if self._initialized:
             return
-        try:
-            self._base_dir.mkdir(parents=True, exist_ok=True)
-        except OSError as exc:
-            raise RuntimeError(
-                f"Cannot create memory directory {self._base_dir}: {exc}. "
-                "Memory tools are unavailable."
-            ) from exc
-        if self._file.exists():
+        with self._lock:
+            # Double-check after acquiring lock — another thread may have
+            # initialized while we were waiting.
+            if self._initialized:
+                return
             try:
-                with open(self._file, "r") as f:
-                    self._data = json.load(f)
-            except (json.JSONDecodeError, ValueError):
-                corrupt = self._file.with_suffix(".json.corrupt")
-                self._file.rename(corrupt)
+                self._base_dir.mkdir(parents=True, exist_ok=True)
+            except OSError as exc:
+                raise RuntimeError(
+                    f"Cannot create memory directory {self._base_dir}: {exc}. "
+                    "Memory tools are unavailable."
+                ) from exc
+            if self._file.exists():
+                try:
+                    with open(self._file, "r") as f:
+                        self._data = json.load(f)
+                except (json.JSONDecodeError, ValueError):
+                    corrupt = self._file.with_suffix(".json.corrupt")
+                    self._file.rename(corrupt)
+                    self._data = {"version": 1, "techniques": []}
+            else:
                 self._data = {"version": 1, "techniques": []}
-        else:
-            self._data = {"version": 1, "techniques": []}
-            self._flush()
-        self._initialized = True
+                self._flush()
+            self._initialized = True
 
     # ── persistence ──────────────────────────────────────────────
 
@@ -263,6 +270,7 @@ class TechniqueStore:
 
     def increment_replay(self, technique_id: str) -> None:
         """Increment replay_count and set last_replayed_at."""
+        self._ensure_initialized()
         with self._lock:
             t = self._find(technique_id)
             t["replay_count"] = t.get("replay_count", 0) + 1

package/mcp_server/mix_engine/critics.py

@@ -134,7 +134,7 @@ def run_dynamics_critic(dynamics: DynamicsState) -> list[MixIssue]:
             recommended_moves=["bus_compression", "transient_shaping"],
         ))
 
-    if dynamics.crest_factor_db < 3.0 and dynamics.crest_factor_db > 0:
+    elif dynamics.crest_factor_db < 3.0 and dynamics.crest_factor_db > 0:
         issues.append(MixIssue(
             issue_type="flat_dynamics",
             critic="dynamics",

package/mcp_server/mix_engine/tools.py

@@ -25,7 +25,7 @@ def _fetch_mix_data(ctx: Context) -> dict:
     ableton = ctx.lifespan_context["ableton"]
 
     session_info = ableton.send_command("get_session_info", {})
-    track_count = session_info.get("track_count", 0)
+    track_count = len(session_info.get("tracks", []))
 
     track_infos: list[dict] = []
     for i in range(track_count):
@@ -35,16 +35,22 @@ def _fetch_mix_data(ctx: Context) -> dict:
         except Exception:
             continue
 
-    # Try to get spectrum and RMS data
+    # Get spectrum and RMS data directly from SpectralCache (not TCP)
     spectrum = None
     rms_data = None
     try:
-        spectrum = ableton.send_command("get_master_spectrum", {})
-    except Exception:
-        pass
-    try:
-        rms_result = ableton.send_command("get_master_rms", {})
-        rms_data = rms_result.get("rms") if isinstance(rms_result, dict) else None
+        spectral = ctx.lifespan_context.get("spectral")
+        if spectral and spectral.is_connected:
+            spec_data = spectral.get("spectrum")
+            if spec_data:
+                spectrum = {"bands": spec_data["value"]}
+                key_data = spectral.get("key")
+                if key_data:
+                    spectrum["detected_key"] = key_data["value"]
+
+            rms_snap = spectral.get("rms")
+            if rms_snap:
+                rms_data = rms_snap["value"] if isinstance(rms_snap["value"], dict) else rms_snap["value"]
     except Exception:
         pass
 

package/mcp_server/performance_engine/safety.py

@@ -41,18 +41,21 @@ BLOCKED_MOVE_TYPES: frozenset = frozenset({
 
 
 def classify_move_safety(move_type: str) -> str:
-    """Classify a move type as 'safe', 'caution', or 'blocked'.
+    """Classify a move type as 'safe', 'caution', 'blocked', or 'unknown'.
 
     Returns:
         'safe' if the move is in SAFE_MOVE_TYPES,
         'blocked' if in BLOCKED_MOVE_TYPES,
-        'caution' otherwise (unknown or caution-class moves).
+        'caution' if in CAUTION_MOVE_TYPES,
+        'unknown' for unrecognized move types.
     """
     if move_type in SAFE_MOVE_TYPES:
         return "safe"
     if move_type in BLOCKED_MOVE_TYPES:
         return "blocked"
-    return "caution"
+    if move_type in CAUTION_MOVE_TYPES:
+        return "caution"
+    return "unknown"
 
 
 # ── Safe move suggestions ─────────────────────────────────────────────

package/mcp_server/project_brain/refresh.py

@@ -6,6 +6,7 @@ Pure computation, zero I/O.
 from __future__ import annotations
 
 import copy
+import dataclasses
 from typing import Optional
 
 from .arrangement_graph import build_arrangement_graph
@@ -35,12 +36,15 @@ def refresh_tracks(
     new_state.session_graph = build_session_graph(session_info)
     new_state.session_graph.freshness.mark_fresh(new_state.revision)
 
-    # Mark role and automation graphs stale since tracks changed
+    # Mark role and automation graphs stale since tracks changed.
+    # Deep-copy freshness so mutations don't leak to the original state.
     new_state.role_graph = copy.copy(state.role_graph)
+    new_state.role_graph.freshness = copy.deepcopy(state.role_graph.freshness)
     new_state.role_graph.freshness.mark_stale(
         f"tracks refreshed: {track_indices}"
     )
     new_state.automation_graph = copy.copy(state.automation_graph)
+    new_state.automation_graph.freshness = copy.deepcopy(state.automation_graph.freshness)
     new_state.automation_graph.freshness.mark_stale(
         f"tracks refreshed: {track_indices}"
     )
@@ -73,8 +77,10 @@ def refresh_arrangement(
     )
     new_state.arrangement_graph.freshness.mark_fresh(new_state.revision)
 
-    # Mark role graph stale since arrangement changed
+    # Mark role graph stale since arrangement changed.
+    # Deep-copy freshness so mutations don't leak to the original state.
     new_state.role_graph = copy.copy(state.role_graph)
+    new_state.role_graph.freshness = copy.deepcopy(state.role_graph.freshness)
     new_state.role_graph.freshness.mark_stale("arrangement refreshed")
 
     return new_state

package/mcp_server/project_brain/tools.py

@@ -78,22 +78,22 @@ def build_project_brain(ctx: Context) -> dict:
         except Exception:
             pass
 
-    # 6. Probe capabilities
+    # 6. Probe capabilities (direct SpectralCache access, not TCP)
     analyzer_ok = False
     analyzer_fresh = False
     flucoma_ok = False
     try:
-        # Check if M4L bridge is responding via spectral cache
-        bridge = ctx.lifespan_context.get("spectral_cache")
-        if bridge:
-            analyzer_ok = True
-            analyzer_fresh = not bridge.is_stale() if hasattr(bridge, "is_stale") else False
-    except Exception:
-        pass
-
-    try:
-        flucoma_resp = ableton.send_command("check_flucoma")
-        flucoma_ok = flucoma_resp.get("available", False)
+        spectral = ctx.lifespan_context.get("spectral")
+        if spectral:
+            analyzer_ok = spectral.is_connected
+            if analyzer_ok:
+                snap = spectral.get("spectrum")
+                analyzer_fresh = snap is not None
+            # Check FluCoMa by looking for any FluCoMa stream data
+            for key in ("spectral_shape", "mel_bands", "chroma", "onset", "novelty", "loudness"):
+                if spectral.get(key) is not None:
+                    flucoma_ok = True
+                    break
     except Exception:
         pass
 

package/mcp_server/reference_engine/tools.py

@@ -41,22 +41,23 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
         "harmonic_character": "",
     }
 
-    # Try to get master RMS / loudness
+    # Get master RMS / loudness and spectrum from SpectralCache directly
     try:
-        rms_result = ableton.send_command("get_master_rms", {})
-        rms = rms_result.get("rms", 0.0) if isinstance(rms_result, dict) else 0.0
-        # Approximate LUFS from RMS (rough heuristic)
-        if rms > 0:
-            import math
-            snapshot["loudness"] = round(20 * math.log10(max(rms, 1e-10)), 2)
-    except Exception:
-        pass
-
-    # Try to get spectrum data
-    try:
-        spectrum = ableton.send_command("get_master_spectrum", {})
-        if isinstance(spectrum, dict):
-            snapshot["spectral"] = spectrum
+        spectral = ctx.lifespan_context.get("spectral")
+        if spectral and spectral.is_connected:
+            rms_snap = spectral.get("rms")
+            if rms_snap:
+                rms = rms_snap["value"] if isinstance(rms_snap["value"], (int, float)) else 0.0
+                if rms > 0:
+                    import math
+                    snapshot["loudness"] = round(20 * math.log10(max(rms, 1e-10)), 2)
+
+            spec_data = spectral.get("spectrum")
+            if spec_data:
+                snapshot["spectral"] = {"bands": spec_data["value"]}
+                key_data = spectral.get("key")
+                if key_data:
+                    snapshot["spectral"]["detected_key"] = key_data["value"]
     except Exception:
         pass
 

package/mcp_server/runtime/action_ledger_models.py

@@ -7,19 +7,26 @@ Classes:
 
 from __future__ import annotations
 
+import threading
 import time
+import uuid
 from dataclasses import dataclass, field
 from typing import Optional
 
 
-# Module-level counter for auto-generating IDs.
+# Thread-safe counter with UUID suffix to prevent collisions across
+# server restarts and concurrent processes.
 _counter: int = 0
+_counter_lock = threading.Lock()
+_session_id = uuid.uuid4().hex[:6]
 
 
 def _next_id() -> str:
     global _counter
-    _counter += 1
-    return f"move_{_counter:04d}"
+    with _counter_lock:
+        _counter += 1
+        seq = _counter
+    return f"move_{_session_id}_{seq:04d}"
 
 
 @dataclass

package/mcp_server/runtime/capability_state.py

@@ -203,10 +203,11 @@ def build_capability_state(
     # ── Overall mode ────────────────────────────────────────────────
     if session_ok and analyzer_ok and analyzer_fresh:
         overall_mode = "normal"
-    elif session_ok and not analyzer_ok:
+    elif session_ok and analyzer_ok:
+        # Analyzer online but data is stale — degraded measurement
         overall_mode = "measured_degraded"
     elif session_ok:
-        # session_ok, analyzer_ok but not fresh
+        # Analyzer offline entirely — must rely on judgment alone
         overall_mode = "judgment_only"
     else:
         overall_mode = "read_only"