livepilot 1.27.0 → 1.27.1

package/mcp_server/grader/client.py

@@ -17,11 +17,14 @@ session state, returning the same shape used by `mcp_server/audit/checks.py`:
 
 from __future__ import annotations
 
+import logging
 from typing import Any, Callable, Iterable
 
 from mcp_server.audit import checks as audit_checks
 from mcp_server.audit.checks import infer_role
 
+_logger = logging.getLogger(__name__)
+
 
 _TRACK_COUNT_WARN = 8
 _TRACK_COUNT_FAIL = 12
@@ -441,11 +444,21 @@ def _aggregate_per_track(
         try:
             result = check_fn(*args)
         except Exception as exc:
+            _logger.warning(
+                "grader check %s failed for criterion %r track %r (%s): %s",
+                getattr(check_fn, "__name__", repr(check_fn)),
+                criterion_id,
+                t.get("index"),
+                t.get("name"),
+                exc,
+                exc_info=True,
+            )
             per_track.append({
                 "track_index": t.get("index"),
                 "name": t.get("name"),
                 "role": role,
                 "severity": "n/a",
+                "errored": True,
                 "summary": f"check failed: {type(exc).__name__}",
                 "issues": [],
                 "evidence": {},
@@ -459,15 +472,30 @@ def _aggregate_per_track(
         })
 
     actionable = [r for r in per_track if r["severity"] != "n/a"]
+    n_errored = sum(1 for r in per_track if r.get("errored"))
 
     if not actionable:
+        if n_errored:
+            # Every checkable track raised — do NOT masquerade an all-error
+            # sweep as a benign no-op pass. Surface it as a failure.
+            return {
+                "id": criterion_id,
+                "passed": False,
+                "severity": "fail",
+                "summary": (
+                    f"{n_errored} track(s) errored during check; no track "
+                    "produced a usable result"
+                ),
+                "issues": [],
+                "evidence": {"per_track": per_track, "errored": n_errored},
+            }
         return {
             "id": criterion_id,
             "passed": True,
             "severity": "n/a",
             "summary": "No checkable tracks (data missing or no applicable role)",
             "issues": [],
-            "evidence": {"per_track": per_track},
+            "evidence": {"per_track": per_track, "errored": n_errored},
         }
 
     has_fail = any(r["severity"] == "fail" for r in actionable)
@@ -505,7 +533,7 @@ def _aggregate_per_track(
         "severity": rubric_severity,
         "summary": summary,
         "issues": issues,
-        "evidence": {"per_track": per_track},
+        "evidence": {"per_track": per_track, "errored": n_errored},
     }
 
 

package/mcp_server/grader/tools.py

@@ -64,9 +64,15 @@ def _build_light_state(ctx: Context) -> dict[str, Any]:
         info = _safe_call(ableton, "get_track_info", {"track_index": idx})
         if not info:
             continue
-        if info.get("is_foldable") and info.get("is_master"):
+        # Skip master/return tracks (real Remote Script field names are
+        # is_master_track / is_return_track, not is_master / is_return).
+        if info.get("is_master_track") or info.get("is_return_track"):
             continue
-        if info.get("is_return"):
+        # Skip group containers — foldable group tracks hold no clips or
+        # devices of their own, so they inflate the §7.3 track count and
+        # (having a mixer volume but no role/ghost tag) trip the
+        # buried-track check. Only count real, content-bearing layers.
+        if info.get("is_foldable"):
             continue
         tracks.append({
             "index": idx,

package/mcp_server/hook_hunter/analyzer.py

@@ -108,8 +108,21 @@ def find_hook_candidates(
     for c in candidates:
         # Check if hook is present in payoff sections (via motif locations)
         if c.hook_type == "melodic" and motif_data:
-            for motif in motif_data.get("motifs", []):
-                if motif.get("name", "") in c.hook_id:
+            for idx, motif in enumerate(motif_data.get("motifs", [])):
+                # BUG-B61 fix: the old test `motif.get("name", "") in c.hook_id`
+                # was always True for real motif data, because the engine emits
+                # `motif_id` (not `name`) so .get("name","") returned "", and
+                # `"" in c.hook_id` is True for every candidate. That boosted
+                # every melodic candidate by every motif's recurrence. Rebuild
+                # the source motif's hook_id exactly as it was constructed above
+                # (motif_id -> name -> idxN fallback) and require an exact match
+                # so each candidate is boosted only by its own source motif.
+                identifier = (
+                    motif.get("motif_id")
+                    or motif.get("name")
+                    or f"idx{idx}"
+                )
+                if f"motif_{identifier}" == c.hook_id:
                     # Motif with high recurrence across sections = stronger hook
                     c.memorability = min(1.0, c.memorability + motif.get("recurrence", 0) * 0.2)
 

package/mcp_server/m4l_bridge.py

@@ -497,6 +497,7 @@ 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._capture_future: Optional[asyncio.Future] = None
         self._miditool_handler: Optional[Callable[[str, dict, list], None]] = None
@@ -733,29 +734,26 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         way we never poison a prior sequence, and the problem surfaces in
         logs if it happens.
         """
-        if index == 0:
+        # Only one response is chunked at a time: send_command serialises on
+        # _cmd_lock, so a single active reassembly bucket is sufficient and we
+        # do NOT need the first packet to be index 0. Accepting chunks in any
+        # order fixes the permanent-loss path where an index>0 chunk arriving
+        # before index 0 (UDP loopback reordering under load) used to split
+        # one response across two buckets that never completed.
+        active = self._chunks.get(self._chunk_key)
+        if active is None or active["total"] != total:
+            # No bucket open, OR a chunk with a different `total` arrived,
+            # meaning a new response started (e.g. the previous one timed out
+            # without ever completing). Evict any stale partial and open fresh.
+            if active is not None:
+                self._chunks.pop(self._chunk_key, None)
+                self._chunk_times.pop(self._chunk_key, None)
             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)
-                self._chunks[key] = {"parts": {}, "total": total}
-                self._chunk_times[key] = time.monotonic()
+            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
 
         if len(self._chunks[key]["parts"]) == total:

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 []

package/mcp_server/project_brain/tools.py

@@ -84,17 +84,41 @@ def build_project_brain(ctx: Context) -> dict:
         except Exception as exc:
             logger.debug("build_project_brain failed: %s", exc)
 
-    # 5b. Build notes_map for role inference.
-    # Shape: {section_id: {track_index: [notes]}}. Without this, role_graph
-    # falls back to "assume all tracks active in every section" which destroys
-    # section-scoped role confidence.
+    # 5b/5c. Single combined grid sweep for notes (role inference) and clip
+    # automation envelopes. Previously these were two separate
+    # N_tracks x N_scenes loops, each issuing a remote round-trip per slot —
+    # including empty slots. We now consult the get_scene_matrix presence grid
+    # (already fetched at step 3 as clip_matrix) and skip slots that are
+    # positively empty, collapsing both sweeps into one pass over the grid.
     #
     # BUG-E1: section_id must match what build_section_graph_from_scenes emits.
     # The composition engine emits `sec_{i:02d}` using the RAW enumerate index
     # of the scene — it skips unnamed scenes (gap-preserving), so e.g. scenes
     # ["Intro", "", "Verse"] become sections sec_00 and sec_02, not sec_01.
-    # Our notes_map must mirror that or keys won't align.
+    # Both maps mirror that or keys won't align.
+    #
+    # clips_scanned is the denominator for coverage_pct (BUG-D2): it counts
+    # the slots we actually probed for envelopes. Slots skipped as empty are
+    # not counted, so coverage_pct stays "fraction of present clips automated".
+    def _slot_is_empty(s_idx: int, t_idx: int) -> bool:
+        """True only when the presence grid positively reports no clip.
+
+        Unknown / out-of-range / malformed cells return False so we still
+        issue the round-trip (safe fallback — never skip on ambiguity).
+        """
+        try:
+            cell = clip_matrix[s_idx][t_idx]
+        except (IndexError, TypeError, KeyError):
+            return False
+        if not isinstance(cell, dict):
+            return False
+        if cell.get("has_clip"):
+            return False
+        return cell.get("state") in ("empty", "missing")
+
     notes_map: dict[str, dict[int, list[dict]]] = {}
+    clip_automation: list[dict] = []
+    clips_scanned = 0
     try:
         for scene_idx, scene in enumerate(scenes or []):
             scene_name = str(scene.get("name", "")).strip()
@@ -105,6 +129,11 @@ def build_project_brain(ctx: Context) -> dict:
             per_track: dict[int, list[dict]] = {}
             for track in tracks:
                 t_idx = track.get("index", 0)
+                if _slot_is_empty(scene_idx, t_idx):
+                    continue  # no clip in this slot — skip both round-trips
+                clips_scanned += 1
+
+                # Notes for role inference.
                 try:
                     notes_resp = ableton.send_command("get_notes", {
                         "track_index": t_idx,
@@ -115,39 +144,9 @@ def build_project_brain(ctx: Context) -> dict:
                         if notes:
                             per_track[t_idx] = notes
                 except Exception as exc:
-                    logger.debug("build_project_brain failed: %s", exc)
-                    # Individual note fetch failing is fine — continue with others
-                    continue
-            if per_track:
-                notes_map[section_id] = per_track
-    except Exception as exc:
-        logger.debug("build_project_brain failed: %s", exc)
-        # Overall failure: empty map, degrade to "all tracks active" fallback
-        notes_map = {}
+                    logger.debug("build_project_brain notes fetch failed: %s", exc)
 
-    # 5c. Scan clip automation across the session (BUG-E2).
-    # Device-parameter is_automated flags only reflect whether a parameter
-    # is mapped somewhere — they don't reveal clip envelopes. Ableton's
-    # automation actually lives on each clip (session + arrangement). We
-    # walk every clip slot that has a clip and ask get_clip_automation, then
-    # aggregate into a flat list keyed by section.
-    #
-    # clips_scanned is the denominator for coverage_pct (BUG-D2) — it
-    # counts how many (track, scene) slots we probed, regardless of
-    # whether an envelope came back. Without this, a session with zero
-    # automation would be indistinguishable from a session where we
-    # failed to probe, which is exactly the ambiguity BUG-D2 flagged.
-    clip_automation: list[dict] = []
-    clips_scanned = 0
-    try:
-        for scene_idx, scene in enumerate(scenes or []):
-            scene_name = str(scene.get("name", "")).strip()
-            if not scene_name:
-                continue
-            section_id = f"sec_{scene_idx:02d}"
-            for track in tracks:
-                t_idx = track.get("index", 0)
-                clips_scanned += 1
+                # Clip automation envelopes (BUG-E2).
                 try:
                     auto_resp = ableton.send_command("get_clip_automation", {
                         "track_index": t_idx,
@@ -156,22 +155,27 @@ def build_project_brain(ctx: Context) -> dict:
                 except Exception as exc:
                     # No clip in slot, or remote script rejected — skip
                     logger.debug("build_project_brain automation skip: %s", exc)
-                    continue
-                if not isinstance(auto_resp, dict):
-                    continue
-                envs = auto_resp.get("envelopes") or []
-                for env in envs:
-                    clip_automation.append({
-                        "section_id": section_id,
-                        "track_index": t_idx,
-                        "track_name": track.get("name", ""),
-                        "clip_index": scene_idx,
-                        "parameter_name": env.get("parameter_name", ""),
-                        "parameter_type": env.get("parameter_type", ""),
-                        "device_name": env.get("device_name"),
-                    })
+                    auto_resp = None
+                if isinstance(auto_resp, dict):
+                    for env in (auto_resp.get("envelopes") or []):
+                        clip_automation.append({
+                            "section_id": section_id,
+                            "track_index": t_idx,
+                            "track_name": track.get("name", ""),
+                            "clip_index": scene_idx,
+                            "parameter_name": env.get("parameter_name", ""),
+                            "parameter_type": env.get("parameter_type", ""),
+                            "device_name": env.get("device_name"),
+                        })
+
+            if per_track:
+                notes_map[section_id] = per_track
     except Exception as exc:
-        logger.debug("build_project_brain automation scan failed: %s", exc)
+        logger.debug("build_project_brain grid sweep failed: %s", exc)
+        # Overall failure: empty maps, degrade to "all tracks active" fallback
+        notes_map = {}
+        clip_automation = []
+        clips_scanned = 0
 
     # 6. Probe capabilities (direct SpectralCache access, not TCP)
     analyzer_ok = False

package/mcp_server/reference_engine/tools.py

@@ -71,14 +71,18 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
 
             spec_data = spectral.get("spectrum")
             if spec_data:
-                snapshot["spectral"] = {"bands": spec_data["value"]}
+                # gap_analyzer.analyze_gaps reads proj_spectral["band_balance"]
+                # and the reference profile stores its bands under the same
+                # key, so the project spectrum MUST go under band_balance too
+                # (writing it under "bands" made every band read as 0.0).
+                snapshot["spectral"] = {"band_balance": spec_data["value"]}
                 key_data = spectral.get("key")
                 if key_data:
                     snapshot["spectral"]["detected_key"] = key_data["value"]
     except Exception as exc:
         logger.debug("_fetch_project_snapshot failed: %s", exc)
 
-    # Try to get session info for pacing / density
+    # Try to get session info for pacing / density / stereo width
     try:
         session_info = ableton.send_command("get_session_info", {})
         track_count = session_info.get("track_count", 0)
@@ -86,6 +90,22 @@ def _fetch_project_snapshot(ctx: Context) -> dict:
         # Rough density estimate
         snapshot["density"] = min(1.0, track_count / 20.0)
         snapshot["pacing"] = [{"label": f"scene_{i}", "bars": 8} for i in range(scene_count)]
+
+        # Estimate project stereo width from track pans (mirrors the
+        # pan-spread estimate in translation_engine/tools.py). Without this,
+        # snapshot["width"] stayed 0.0 and the width gap always reported the
+        # full reference width.
+        tracks = session_info.get("tracks", [])
+        if tracks:
+            def _get_pan(t: dict) -> float:
+                mixer = t.get("mixer")
+                if isinstance(mixer, dict):
+                    return abs(mixer.get("panning", 0.0))
+                return abs(t.get("pan", 0.0))
+
+            pan_values = [_get_pan(t) for t in tracks if not t.get("muted", False)]
+            if pan_values:
+                snapshot["width"] = min(1.0, sum(pan_values) / max(len(pan_values), 1))
     except Exception as exc:
         logger.debug("_fetch_project_snapshot failed: %s", exc)
 

package/mcp_server/runtime/live_version.py

@@ -6,6 +6,7 @@ responses and exposes feature flags for tool routing.
 
 from __future__ import annotations
 
+import re
 from dataclasses import dataclass
 
 
@@ -19,21 +20,39 @@ class LiveVersionCapabilities:
 
     @classmethod
     def from_version_string(cls, version_str: str) -> LiveVersionCapabilities:
-        """Parse '12.3.6' into a capabilities instance."""
-        parts = version_str.split(".")
-        major = int(parts[0]) if len(parts) > 0 else 12
-        minor = int(parts[1]) if len(parts) > 1 else 0
-        patch = int(parts[2]) if len(parts) > 2 else 0
+        """Parse '12.3.6' into a capabilities instance.
+
+        Tolerant of malformed input: extracts the leading integer of each
+        dotted component and falls back to the conservative floor
+        (major=12, minor=0, patch=0) for missing or non-numeric components.
+        Mirrors the Remote Script's degrade-to-(12,0,0) contract
+        (remote_script/LivePilot/version_detect.py) so a junk live_version
+        string never crashes get_capability_state / get_session_kernel /
+        --doctor.
+        """
+        def _component(parts: list[str], index: int, default: int) -> int:
+            if index >= len(parts):
+                return default
+            match = re.match(r"\s*(\d+)", parts[index])
+            return int(match.group(1)) if match else default
+
+        parts = (version_str or "").split(".")
+        major = _component(parts, 0, 12)
+        minor = _component(parts, 1, 0)
+        patch = _component(parts, 2, 0)
         return cls(major=major, minor=minor, patch=patch)
 
     @classmethod
     def from_session_info(cls, session_info: dict) -> LiveVersionCapabilities:
         """Extract version from get_session_info response.
 
-        Looks for 'live_version' field. Falls back to 12.0.0 if absent
-        (pre-upgrade Remote Script).
+        Looks for 'live_version' field. Falls back to 12.0.0 if absent,
+        null, or empty (pre-upgrade Remote Script). Uses a falsy-guard
+        rather than a key-presence default so a present-but-empty value
+        degrades to the conservative floor, aligning with the sibling
+        readers in runtime/tools.py and runtime/capability_probe.py.
         """
-        version_str = session_info.get("live_version", "12.0.0")
+        version_str = session_info.get("live_version") or "12.0.0"
         return cls.from_version_string(version_str)
 
     @property

package/mcp_server/runtime/safety_kernel.py

@@ -56,6 +56,15 @@ CONFIRM_REQUIRED_ACTIONS: set[str] = {
     "replace_simpler_sample",
 }
 
+# Names that LOOK read-only by prefix but actually mutate session state.
+# These must NOT be classified as read-only — they are intersected against
+# the prefix matcher below so a mutating verb never slips through a read
+# prefix (e.g. ``find_and_load_device`` starts with ``find_`` but loads a
+# device, a real mutation routed through REMOTE_COMMANDS).
+_MUTATING_OVERRIDES: set[str] = {
+    "find_and_load_device",
+}
+
 # Read-only prefixes — any action starting with one of these is a read.
 _READ_ONLY_PREFIXES = (
     "get_",
@@ -203,6 +212,8 @@ _WIDE_SCOPE_THRESHOLD = 5   # tracks
 
 def is_read_only_action(action: str) -> bool:
     """Return True if *action* is a non-mutating read/query."""
+    if action in _MUTATING_OVERRIDES:
+        return False
     if action in SAFE_ACTIONS:
         return True
     return action.startswith(_READ_ONLY_PREFIXES)