livepilot 1.27.0 → 1.27.2

package/mcp_server/m4l_bridge.py

@@ -30,6 +30,7 @@ import socket
 import struct
 import threading
 import time
+import uuid
 from typing import Any, Callable, Optional
 
 
@@ -477,7 +478,10 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         /rms f                     — RMS level
         /pitch f f                 — MIDI note, amplitude
         /response s                — base64-encoded JSON (single packet)
-        /response_chunk i i s      — chunked response (index, total, data)
+        /response_chunk [s] i i s  — chunked response. New builds prefix the
+                                     per-response request id so chunks of
+                                     different commands never share a bucket;
+                                     legacy builds omit it: (index, total, data)
     """
 
     # Band names keyed by how many bands the .amxd emits. 8 bands is the v1.x
@@ -497,7 +501,14 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         self._chunks: dict[str, dict] = {}  # Reassembly buffer for chunked responses
         self._chunk_times: dict[str, float] = {}  # Monotonic timestamp per chunk sequence
         self._chunk_id = 0
+        self._chunk_key: Optional[str] = None  # Key of the single active reassembly bucket
         self._response_callback: Optional[asyncio.Future] = None
+        self._response_request_id: Optional[str] = None
+        # Set True the first time a response arrives carrying a request id.
+        # Once the analyzer build is known to stamp ids, a response that
+        # arrives with NO id (or a mismatched one) while a future is live is a
+        # stale straggler and must be dropped — see _handle_response.
+        self._seen_request_id = False
         self._capture_future: Optional[asyncio.Future] = None
         self._miditool_handler: Optional[Callable[[str, dict, list], None]] = None
 
@@ -652,7 +663,16 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             self._handle_response(str(args[0]))
 
         elif address == "/response_chunk" and len(args) >= 3:
-            self._handle_chunk(int(args[0]), int(args[1]), str(args[2]))
+            # New builds prefix the request id (string): (rid, index, total, data).
+            # Legacy builds send (index, total, data). Distinguish by the type
+            # of the first arg — OSC ints decode to int, the id to a str.
+            if len(args) >= 4 and isinstance(args[0], str):
+                self._handle_chunk(
+                    int(args[1]), int(args[2]), str(args[3]),
+                    request_id=str(args[0]),
+                )
+            else:
+                self._handle_chunk(int(args[0]), int(args[1]), str(args[2]))
 
         elif address == "/miditool/request" and len(args) >= 1:
             self._handle_miditool_request(str(args[0]))
@@ -664,24 +684,52 @@ class SpectralReceiver(asyncio.DatagramProtocol):
     def _handle_response(self, encoded: str) -> None:
         """Decode a single-packet base64 response.
 
-        Resolves _response_callback exactly once, then clears it. Without the
-        clear, a second late packet could overwrite a future belonging to a
-        different in-flight command. The protocol has no request id yet
-        (livepilot_bridge.js:666 emits bare /response), so correlation relies
-        on the single-command-in-flight invariant enforced by M4LBridge._cmd_lock
-        plus this one-shot clear.
+        Updated analyzer JS echoes ``_livepilot_request_id`` on every response
+        (single-packet here, and on the chunk header for chunked responses).
+        Correlation rules, once this device is known to stamp ids:
+          * a response whose id does NOT match the in-flight future is dropped;
+          * a response with NO id at all is also dropped — it is a stale
+            straggler (e.g. a batched read that outlived its timeout), not a
+            pre-request-id build.
+        Pre-request-id builds (which never stamp an id) stay supported: until
+        the first id is ever seen, no-id responses are accepted.
         """
         try:
             # URL-safe base64 decode (- and _ instead of + and /)
             padded = encoded + "=" * (-len(encoded) % 4)
             decoded = base64.urlsafe_b64decode(padded).decode('utf-8')
             result = _normalize_bridge_payload(json.loads(decoded))
+            response_request_id = None
+            if isinstance(result, dict):
+                response_request_id = result.pop("_livepilot_request_id", None)
+
+            if response_request_id is not None:
+                # This analyzer build stamps request ids — remember it so a
+                # later no-id straggler is recognised as stale rather than
+                # mistaken for an old build that never sends ids.
+                self._seen_request_id = True
+
             cb = self._response_callback
+            expected_request_id = self._response_request_id
+            if cb and not cb.done() and expected_request_id is not None:
+                mismatched = (
+                    response_request_id is not None
+                    and str(response_request_id) != str(expected_request_id)
+                )
+                missing_but_expected = (
+                    response_request_id is None and self._seen_request_id
+                )
+                if mismatched or missing_but_expected:
+                    # Stale/uncorrelated reply — drop it and keep waiting for
+                    # the response that actually matches this command.
+                    return
+
             if cb and not cb.done():
                 cb.set_result(result)
             # Clear regardless — either we consumed it, or it was already
             # done/abandoned. Future packets with no owner get dropped.
             self._response_callback = None
+            self._response_request_id = None
         except Exception as exc:
             import sys
             print(f"LivePilot: failed to decode bridge response: {exc}", file=sys.stderr)
@@ -717,52 +765,62 @@ class SpectralReceiver(asyncio.DatagramProtocol):
                 import sys
                 print(f"LivePilot: miditool handler error: {exc}", file=sys.stderr)
 
-    def _handle_chunk(self, index: int, total: int, encoded: str) -> None:
+    def _handle_chunk(
+        self,
+        index: int,
+        total: int,
+        encoded: str,
+        request_id: Optional[str] = None,
+    ) -> None:
         """Reassemble chunked responses.
 
-        The previous implementation incremented ``_chunk_id`` only when
-        ``index == 0`` and assumed the first chunk always arrived first.
-        Under UDP reordering (rare on loopback but possible under system
-        load), a chunk with ``index > 0`` arriving before ``index 0`` would
-        be dropped into the PREVIOUS sequence's bucket — silently corrupting
-        that earlier response's payload.
-
-        Until the wire protocol adds an explicit sequence id, the safer
-        behavior is: if we see an out-of-order first-chunk (``index > 0``
-        with no open bucket), start a fresh bucket but log a warning. That
-        way we never poison a prior sequence, and the problem surfaces in
-        logs if it happens.
+        New analyzer builds stamp the per-response request id on every
+        ``/response_chunk`` header, so chunks from different commands land in
+        SEPARATE buckets and can never be interleaved — even if a stale chunk
+        from a timed-out command arrives mid-flight. Legacy builds omit the id
+        (``request_id`` None/""); they fall back to a single rolling bucket,
+        which is safe because ``send_command`` serialises on ``_cmd_lock``.
+
+        Hardening (v1.27.2): an index outside ``[0, total)`` is dropped — a
+        duplicate or malformed packet must never count toward completion — and
+        reassembly only fires once EVERY index ``0..total-1`` is present. The
+        old ``len(parts) == total`` check could KeyError on a duplicate or
+        out-of-range index, silently losing the response and forcing a full
+        timeout.
         """
-        if index == 0:
-            self._chunk_id += 1
-            key = str(self._chunk_id)
-            self._chunks[key] = {"parts": {}, "total": total}
-            self._chunk_times[key] = time.monotonic()
-        else:
-            key = str(self._chunk_id)
-            if key not in self._chunks:
-                # Out-of-order arrival. Start a new bucket rather than append
-                # to the previous sequence's parts — that's the corruption
-                # path. Log once so it's diagnosable.
-                import sys
-                print(
-                    f"LivePilot: chunk index={index}/{total} arrived before "
-                    f"index=0 — starting fresh bucket. UDP reordering on "
-                    f"loopback suggests system load.",
-                    file=sys.stderr,
-                )
-                self._chunk_id += 1
-                key = str(self._chunk_id)
+        # Drop chunks that cannot belong to a well-formed response.
+        if total <= 0 or index < 0 or index >= total:
+            return
+
+        if request_id:
+            # Collision-free per-response bucket.
+            key = f"rid:{request_id}"
+            active = self._chunks.get(key)
+            if active is None or active["total"] != total:
                 self._chunks[key] = {"parts": {}, "total": total}
                 self._chunk_times[key] = time.monotonic()
+            self._chunk_key = key
+        else:
+            # Legacy single-active-bucket model (no id on the wire). A chunk
+            # with a different `total` means a new response started (e.g. the
+            # previous one timed out without ever completing) — evict + reopen.
+            active = self._chunks.get(self._chunk_key)
+            if active is None or active["total"] != total:
+                if active is not None:
+                    self._chunks.pop(self._chunk_key, None)
+                    self._chunk_times.pop(self._chunk_key, None)
+                self._chunk_id += 1
+                self._chunk_key = str(self._chunk_id)
+                self._chunks[self._chunk_key] = {"parts": {}, "total": total}
+                self._chunk_times[self._chunk_key] = time.monotonic()
+            key = self._chunk_key
 
-        self._chunks[key]["parts"][index] = encoded
+        parts = self._chunks[key]["parts"]
+        parts[index] = encoded
 
-        if len(self._chunks[key]["parts"]) == total:
-            # All chunks received — reassemble
-            full = ""
-            for i in range(total):
-                full += self._chunks[key]["parts"][i]
+        if len(parts) == total and all(i in parts for i in range(total)):
+            # Every chunk present — reassemble in order.
+            full = "".join(parts[i] for i in range(total))
             del self._chunks[key]
             self._chunk_times.pop(key, None)
             self._handle_response(full)
@@ -782,13 +840,22 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             result = _normalize_bridge_payload(json.loads(decoded))
             if self._capture_future and not self._capture_future.done():
                 self._capture_future.set_result(result)
+            # Clear the reference so a completed future isn't retained until the
+            # next capture, and so send_capture's done()-guarded cancel has no
+            # stale object to consider.
+            self._capture_future = None
         except Exception as exc:
             import sys
             print(f"LivePilot: failed to decode capture response: {exc}", file=sys.stderr)
 
-    def set_response_future(self, future: asyncio.Future) -> None:
+    def set_response_future(
+        self,
+        future: Optional[asyncio.Future],
+        request_id: Optional[str] = None,
+    ) -> None:
         """Set a future to be resolved with the next response."""
         self._response_callback = future
+        self._response_request_id = request_id if future is not None else None
 
     def set_capture_future(self, future: asyncio.Future) -> None:
         """Set a future to be resolved when a capture_complete OSC arrives."""
@@ -812,6 +879,12 @@ class M4LBridge:
         self.receiver = receiver
         self.miditool_cache = miditool_cache
         self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        # Non-blocking so a momentarily-full send buffer never stalls the
+        # asyncio event loop. The miditool response path sends from inside a
+        # DatagramProtocol callback that runs ON the loop thread — a blocking
+        # sendto there would freeze every pending coroutine. UDP loopback sends
+        # essentially never block; _safe_sendto guards the rare case anyway.
+        self._sock.setblocking(False)
         self._m4l_addr = ("127.0.0.1", 9881)
         self._cmd_lock: Optional[asyncio.Lock] = None
         # BUG-audit-C1: send_capture uses _capture_future, which is
@@ -827,6 +900,22 @@ class M4LBridge:
             if self.receiver.miditool_cache is None and miditool_cache is not None:
                 self.receiver.miditool_cache = miditool_cache
 
+    def _safe_sendto(self, data: bytes) -> None:
+        """Send a UDP packet without ever blocking the event loop.
+
+        The socket is non-blocking; if the OS send buffer is momentarily full
+        (vanishingly rare on loopback) sendto raises BlockingIOError. We drop
+        the packet rather than stall — the caller's timeout/retry handles it.
+        """
+        try:
+            self._sock.sendto(data, self._m4l_addr)
+        except BlockingIOError:
+            import sys
+            print(
+                "LivePilot: M4L UDP send buffer full — packet dropped",
+                file=sys.stderr,
+            )
+
     def _dispatch_miditool_request(
         self, request_id: str, context: dict, notes: list,
     ) -> None:
@@ -871,7 +960,7 @@ class M4LBridge:
         """
         payload = {"tool_name": tool_name or "", "params": params or {}}
         osc = self._build_osc("miditool/config", (json.dumps(payload),))
-        self._sock.sendto(osc, self._m4l_addr)
+        self._safe_sendto(osc)
 
     def send_miditool_response(self, request_id: str, notes: list) -> None:
         """Send transformed notes back to the JS bridge.
@@ -881,7 +970,7 @@ class M4LBridge:
         """
         payload = {"request_id": str(request_id or ""), "notes": list(notes or [])}
         osc = self._build_osc("miditool/response", (json.dumps(payload),))
-        self._sock.sendto(osc, self._m4l_addr)
+        self._safe_sendto(osc)
 
     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."""
@@ -907,12 +996,14 @@ class M4LBridge:
             # Create a future for the response
             loop = asyncio.get_running_loop()
             future = loop.create_future()
-            self.receiver.set_response_future(future)
+            request_id = uuid.uuid4().hex
+            self.receiver.set_response_future(future, request_id=request_id)
 
             # Build and send OSC message (no leading / — Max udpreceive
             # passes messagename with / intact to JS, breaking dispatch)
-            osc_data = self._build_osc(command, args)
-            self._sock.sendto(osc_data, self._m4l_addr)
+            request_arg = f"__livepilot_request_id:{request_id}"
+            osc_data = self._build_osc(command, (*args, request_arg))
+            self._safe_sendto(osc_data)
 
             # Wait for response with timeout
             try:
@@ -960,7 +1051,7 @@ class M4LBridge:
             self.receiver.set_capture_future(future)
 
             osc_data = self._build_osc(command, args)
-            self._sock.sendto(osc_data, self._m4l_addr)
+            self._safe_sendto(osc_data)
 
             try:
                 result = await asyncio.wait_for(future, timeout=timeout)

package/mcp_server/memory/taste_graph.py

@@ -182,6 +182,14 @@ class TasteGraph:
         self.evidence_count += 1
         self.last_updated_ms = now
 
+        # Write-back to persistent store
+        if self._persistent_store is not None:
+            try:
+                self._persistent_store.record_device_use(device_name, positive)
+            except Exception as exc:
+                logger.debug("record_device_use failed: %s", exc)
+                pass  # persistence is best-effort
+
     def update_novelty_from_experiment(
         self, chose_bold: bool, goal_mode: str = "improve",
     ) -> None:
@@ -200,6 +208,14 @@ class TasteGraph:
             new_val = max(0.0, current - 0.05)
         self.novelty_bands[goal_mode] = new_val
 
+        # Write-back to persistent store
+        if self._persistent_store is not None:
+            try:
+                self._persistent_store.update_novelty(chose_bold, goal_mode)
+            except Exception as exc:
+                logger.debug("update_novelty failed: %s", exc)
+                pass  # persistence is best-effort
+
     # ── Ranking ──────────────────────────────────────────────────────
 
     def rank_moves(

package/mcp_server/memory/technique_store.py

@@ -31,6 +31,19 @@ class TechniqueStore:
         self._lock = threading.Lock()
         self._initialized = False
         self._data: dict = {"version": 1, "techniques": []}
+        # Signature (mtime_ns, size) of the file as we last loaded it. Lets
+        # multiple TechniqueStore instances pointing at the same file pick up
+        # each other's writes (reload-on-read) instead of caching stale data
+        # for the life of the process.
+        self._loaded_sig: Optional[tuple] = None
+
+    def _file_signature(self) -> Optional[tuple]:
+        """Return (mtime_ns, size) of the backing file, or None if absent."""
+        try:
+            st = self._file.stat()
+        except OSError:
+            return None
+        return (st.st_mtime_ns, st.st_size)
 
     def _ensure_initialized(self) -> None:
         """Lazily create directory and load data on first access.
@@ -40,12 +53,14 @@ class TechniqueStore:
         Thread-safe: uses double-checked locking to prevent concurrent
         callers from racing on initialization.
         """
-        if self._initialized:
+        # Fast path: already initialized AND the file on disk has not changed
+        # since we last loaded it (no other instance has written).
+        if self._initialized and self._file_signature() == self._loaded_sig:
             return
         with self._lock:
             # Double-check after acquiring lock — another thread may have
-            # initialized while we were waiting.
-            if self._initialized:
+            # (re)loaded while we were waiting.
+            if self._initialized and self._file_signature() == self._loaded_sig:
                 return
             try:
                 self._base_dir.mkdir(parents=True, exist_ok=True)
@@ -58,10 +73,12 @@ class TechniqueStore:
                 try:
                     with open(self._file, "r") as f:
                         self._data = json.load(f)
+                    self._loaded_sig = self._file_signature()
                 except (json.JSONDecodeError, ValueError):
                     corrupt = self._file.with_suffix(".json.corrupt")
                     self._file.rename(corrupt)
                     self._data = {"version": 1, "techniques": []}
+                    self._loaded_sig = None
             else:
                 self._data = {"version": 1, "techniques": []}
                 self._flush()
@@ -77,6 +94,9 @@ class TechniqueStore:
             f.flush()
             os.fsync(f.fileno())
         os.replace(str(tmp), str(self._file))
+        # Record the signature of our own write so this instance does not
+        # needlessly reload the data it already holds in memory.
+        self._loaded_sig = self._file_signature()
 
     # ── public API ───────────────────────────────────────────────
 

package/mcp_server/mix_engine/state_builder.py

@@ -241,8 +241,10 @@ def build_dynamics_state(
 
     crest = 20 * math.log10(max(peak_linear, 1e-10) / max(rms_linear, 1e-10))
 
-    # Over-compressed when crest factor < 6 dB (flat dynamics)
-    over_compressed = crest < 6.0
+    # Over-compressed band is 3-6 dB crest. Below 3 dB the signal is so flat
+    # that the dynamics critic should report the stronger `flat_dynamics`
+    # issue instead, which only fires when over_compressed is False.
+    over_compressed = 3.0 <= crest < 6.0
 
     # Headroom = distance from peak to 0 dBFS
     if peak_linear > 0:

package/mcp_server/musical_intelligence/detectors.py

@@ -134,9 +134,15 @@ def detect_repetition_fatigue(
         staleness = min(1.0, (reuse_count / total - 1) * 0.3) if total else 0
         report.section_staleness[name] = round(max(0, staleness), 3)
 
-    # Overall fatigue level
+    # Overall fatigue level — saturating combine (probabilistic OR) so that
+    # adding more issues never *reduces* fatigue. A plain mean would let a
+    # cluster of low-severity issues dilute a single serious one.
     if report.issues:
-        report.fatigue_level = min(1.0, sum(i["severity"] for i in report.issues) / max(1, len(report.issues)))
+        remaining_freshness = 1.0
+        for issue in report.issues:
+            severity = max(0.0, min(1.0, issue["severity"]))
+            remaining_freshness *= (1.0 - severity)
+        report.fatigue_level = min(1.0, 1.0 - remaining_freshness)
 
     # Recommendations
     if report.fatigue_level > 0.5:
@@ -337,6 +343,9 @@ def infer_section_purposes(
         if position < 0.15 and density < 0.5:
             purpose = "setup"
             confidence = 0.7
+        elif density >= 0.8 and density_delta >= 0:
+            purpose = "payoff"
+            confidence = 0.65
         elif density_delta > 0.2:
             purpose = "tension"
             confidence = 0.6

package/mcp_server/musical_intelligence/tools.py

@@ -215,8 +215,21 @@ def compare_phrase_renders(
 
     critiques = []
     for path in file_paths:
-        # Try to get cached analysis or run fresh
-        critique = phrase_critic.analyze_phrase(target=target)
+        # Run offline analysis per file so each render gets a real critique
+        loudness_data = None
+        spectrum_data = None
+        try:
+            from ..tools._perception_engine import compute_loudness
+            loudness_data = compute_loudness(path, detail="full")
+        except Exception as exc:
+            logger.debug("compare_phrase_renders loudness failed for %s: %s", path, exc)
+        try:
+            from ..tools._perception_engine import compute_spectral
+            spectrum_data = compute_spectral(path)
+        except Exception as exc:
+            logger.debug("compare_phrase_renders spectral failed for %s: %s", path, exc)
+
+        critique = phrase_critic.analyze_phrase(loudness_data, spectrum_data, target)
         critique.render_id = path.split("/")[-1] if isinstance(path, str) and "/" in path else str(path)
         critiques.append(critique)
 

package/mcp_server/preview_studio/engine.py

@@ -33,6 +33,35 @@ def store_preview_set(ps: PreviewSet) -> None:
         del _preview_sets[oldest_key]
 
 
+# Statuses that represent work a user (or caller) has already invested in:
+# a compared ranking or a committed pick. A fresh request that hashes to the
+# same set_id must NOT clobber these — it branches to a distinct id instead.
+_PROTECTED_STATUSES = {"committed", "compared"}
+
+
+def _resolve_set_id(base_id: str) -> str:
+    """Return a set_id that won't clobber a protected (committed/compared) set.
+
+    The base_id is a deterministic hash of request_text + kernel_id, so a
+    re-request reuses it by design. That reuse is fine while the existing set
+    is still 'pending'/'discarded' (nothing of value to lose). But if the
+    existing set under base_id has been compared or committed, overwriting it
+    would silently drop its rankings / committed pick. In that case we branch
+    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)
+    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)
+        if occupant is None or occupant.status not in _PROTECTED_STATUSES:
+            return candidate
+        suffix += 1
+
+
 # ── Creation ──────────────────────────────────────────────────────
 
 
@@ -58,7 +87,7 @@ def create_preview_set(
         flags the resulting PreviewSet with ``degradation.is_degraded=True``
         so callers can tell a synthesized compile from a real one.
     """
-    set_id = _compute_set_id(request_text, kernel_id)
+    set_id = _resolve_set_id(_compute_set_id(request_text, kernel_id))
     now = int(time.time() * 1000)
 
     moves = available_moves or []