livepilot 1.10.7 → 1.10.9

package/mcp_server/m4l_bridge.py

@@ -303,13 +303,43 @@ class SpectralReceiver(asyncio.DatagramProtocol):
             print(f"LivePilot: failed to decode bridge response: {exc}", file=sys.stderr)
 
     def _handle_chunk(self, index: int, total: int, encoded: str) -> None:
-        """Reassemble chunked responses."""
+        """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.
+        """
         if index == 0:
             self._chunk_id += 1
-        key = str(self._chunk_id)
-        if key not in self._chunks:
+            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._chunks[key]["parts"][index] = encoded
 
@@ -369,14 +399,26 @@ class M4LBridge:
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        # Fail fast if there is no receiver to correlate the response. The
+        # previous version sent the OSC packet anyway, dropped the reply
+        # inside _handle_response (no future registered), and waited out
+        # the full 5s timeout before returning a misleading "device may be
+        # busy or removed" error. The real cause was "no receiver wired",
+        # which the caller should see immediately.
+        if self.receiver is None:
+            return {
+                "error": "M4L bridge has no active receiver — the UDP 9880 "
+                         "listener did not start. Check server startup logs "
+                         "for a bind failure on port 9880."
+            }
+
         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()
             future = loop.create_future()
-            if self.receiver:
-                self.receiver.set_response_future(future)
+            self.receiver.set_response_future(future)
 
             # Build and send OSC message (no leading / — Max udpreceive
             # passes messagename with / intact to JS, breaking dispatch)
@@ -394,25 +436,35 @@ class M4LBridge:
                 # cleared it inside _handle_response, but calling again is a
                 # no-op. On timeout this is what prevents a delayed packet from
                 # resolving a future belonging to the next command.
-                if self.receiver:
-                    self.receiver.set_response_future(None)
+                self.receiver.set_response_future(None)
 
     async def send_capture(self, command: str, *args: Any, timeout: float = 35.0) -> dict:
         """Send a capture command to the M4L device and wait for /capture_complete."""
         if not self.cache.is_connected:
             return {"error": "LivePilot Analyzer not connected. Drop it on the master track."}
 
+        # Fail fast if there is no receiver to correlate the reply. Prior
+        # versions sent the OSC packet anyway, never registered a future,
+        # and then waited out the full 35s timeout with a misleading
+        # "device may be busy or removed" diagnosis — the real cause was
+        # "no receiver wired" (UDP 9880 failed to bind at startup).
+        if self.receiver is None:
+            return {
+                "error": "M4L bridge has no active receiver — the UDP 9880 "
+                         "listener did not start. Check server startup logs "
+                         "for a bind failure on port 9880."
+            }
+
         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():
+            if self.receiver._capture_future and not self.receiver._capture_future.done():
                 self.receiver._capture_future.cancel()
 
             loop = asyncio.get_running_loop()
             future = loop.create_future()
-            if self.receiver:
-                self.receiver.set_capture_future(future)
+            self.receiver.set_capture_future(future)
 
             osc_data = self._build_osc(command, args)
             self._sock.sendto(osc_data, self._m4l_addr)
@@ -422,8 +474,7 @@ class M4LBridge:
                 return result
             except asyncio.TimeoutError:
                 # Clean up the dangling future
-                if self.receiver:
-                    self.receiver._capture_future = None
+                self.receiver._capture_future = None
                 return {"error": "M4L capture timeout — device may be busy or removed"}
 
     async def cancel_capture_future(self) -> None:

package/mcp_server/project_brain/automation_graph.py

@@ -12,6 +12,7 @@ def build_automation_graph(
     track_infos: list[dict],
     sections: list[dict] | None = None,
     clip_automation: list[dict] | None = None,
+    clips_scanned: int = 0,
 ) -> AutomationGraph:
     """Build an AutomationGraph covering both device-parameter automation
     hints and real clip envelopes (BUG-E2).
@@ -27,11 +28,17 @@ def build_automation_graph(
               parameter_name, parameter_type, device_name}].
             This is the ground truth — `device.parameters[i].is_automated`
             only reflects mapping state, not the presence of an envelope.
+        clips_scanned: total number of session clips the caller actually
+            probed for envelopes. Used to compute ``coverage_pct``; pass 0
+            when the caller couldn't enumerate clips (unknown → 0.0).
 
     Returns:
-        AutomationGraph with automated_params and density_by_section.
+        AutomationGraph with automated_params, density_by_section, and
+        the v1.10.9 coverage signals (coverage_pct, clip_envelope_count,
+        clips_scanned).
     """
     graph = AutomationGraph()
+    graph.clips_scanned = max(0, int(clips_scanned))
 
     if not track_infos and not clip_automation:
         return graph
@@ -121,4 +128,19 @@ def build_automation_graph(
             else:
                 graph.density_by_section[section_id] = 0.0
 
+    # BUG-D2 coverage signals.
+    # clip_envelope_count = distinct (track, clip) slots containing any envelope.
+    clip_slots_with_envelope: set[tuple[int, int | None]] = set()
+    for env in clip_automation or []:
+        clip_slots_with_envelope.add(
+            (int(env.get("track_index", -1)), env.get("clip_index"))
+        )
+    graph.clip_envelope_count = len(clip_slots_with_envelope)
+    if graph.clips_scanned > 0:
+        graph.coverage_pct = min(
+            1.0, graph.clip_envelope_count / float(graph.clips_scanned)
+        )
+    else:
+        graph.coverage_pct = 0.0
+
     return graph

package/mcp_server/project_brain/builder.py

@@ -24,6 +24,7 @@ def build_project_state_from_data(
     notes_map: Optional[dict[str, dict[int, list[dict]]]] = None,
     arrangement_clips: Optional[dict] = None,
     clip_automation: Optional[list[dict]] = None,
+    clips_scanned: int = 0,
     analyzer_ok: bool = False,
     flucoma_ok: bool = False,
     plugin_health: Optional[dict[str, Any]] = None,
@@ -107,6 +108,7 @@ def build_project_state_from_data(
         track_infos=track_infos or [],
         sections=section_dicts_for_auto,
         clip_automation=clip_automation or [],
+        clips_scanned=clips_scanned,
     )
     state.automation_graph.freshness.mark_fresh(state.revision)
 

package/mcp_server/project_brain/models.py

@@ -205,16 +205,35 @@ class RoleGraph:
 
 @dataclass
 class AutomationGraph:
-    """Automation presence and gesture density."""
+    """Automation presence and gesture density.
+
+    ``coverage_pct`` is the fraction of scanned clips that have at least
+    one automation envelope (0.0–1.0). Introduced in v1.10.9 to close
+    BUG-D2's "is this session missing automation?" signal — downstream
+    engines (Wonder Mode, Sound Design, etc.) can branch on a low
+    coverage value to recommend filter sweeps, volume crescendos, and
+    dub-style handoffs that the producer hasn't written yet.
+
+    ``clip_envelope_count`` is the raw total of per-clip envelopes
+    discovered; distinguishes "no automation in the project at all"
+    (count=0) from "automation exists but is lightly used" (count>0 but
+    coverage_pct<0.2).
+    """
 
     automated_params: list[dict] = field(default_factory=list)
     density_by_section: dict[str, float] = field(default_factory=dict)
+    coverage_pct: float = 0.0
+    clip_envelope_count: int = 0
+    clips_scanned: int = 0
     freshness: FreshnessInfo = field(default_factory=FreshnessInfo)
 
     def to_dict(self) -> dict:
         return {
             "automated_params": list(self.automated_params),
             "density_by_section": dict(self.density_by_section),
+            "coverage_pct": round(self.coverage_pct, 3),
+            "clip_envelope_count": self.clip_envelope_count,
+            "clips_scanned": self.clips_scanned,
             "freshness": self.freshness.to_dict(),
         }
 

package/mcp_server/project_brain/tools.py

@@ -131,11 +131,15 @@ def build_project_brain(ctx: Context) -> dict:
     # 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:
-        # Iterate session scenes x tracks, plus arrangement clips we already have.
-        # Use the raw enumerate index for section_id so it stays aligned with
-        # arrangement_graph sections (which use the same scheme — see E1 fix).
         for scene_idx, scene in enumerate(scenes or []):
             scene_name = str(scene.get("name", "")).strip()
             if not scene_name:
@@ -143,6 +147,7 @@ def build_project_brain(ctx: Context) -> dict:
             section_id = f"sec_{scene_idx:02d}"
             for track in tracks:
                 t_idx = track.get("index", 0)
+                clips_scanned += 1
                 try:
                     auto_resp = ableton.send_command("get_clip_automation", {
                         "track_index": t_idx,
@@ -196,6 +201,7 @@ def build_project_brain(ctx: Context) -> dict:
         notes_map=notes_map if notes_map else None,
         arrangement_clips=arrangement_clips if arrangement_clips else None,
         clip_automation=clip_automation if clip_automation else None,
+        clips_scanned=clips_scanned,
         analyzer_ok=analyzer_ok,
         flucoma_ok=flucoma_ok,
         session_ok=True,
@@ -230,6 +236,7 @@ def get_project_brain_summary(ctx: Context) -> dict:
         "section_count": len(state.arrangement_graph.sections),
         "role_count": len(state.role_graph.roles),
         "automated_param_count": len(state.automation_graph.automated_params),
+        "automation_coverage_pct": round(state.automation_graph.coverage_pct, 3),
         "tempo": state.session_graph.tempo,
         "time_signature": state.session_graph.time_signature,
         "is_stale": state.is_stale(),

package/mcp_server/runtime/execution_router.py

@@ -326,8 +326,22 @@ async def execute_plan_steps_async(
         results.append(result)
 
         # Record successful step result for future bindings
-        if result.ok and step_id and isinstance(result.result, dict):
-            step_results[step_id] = result.result
+        if result.ok and step_id:
+            if isinstance(result.result, dict):
+                step_results[step_id] = result.result
+            else:
+                # Log but DO NOT silently drop the binding without telling
+                # anyone — the previous version let non-dict results slip
+                # past, which meant any downstream {"$from_step": step_id}
+                # reference blew up with a confusing "step_id not found"
+                # instead of the real "result wasn't a dict" cause.
+                import logging as _logging
+                _logging.getLogger(__name__).warning(
+                    "step_results: dropping non-dict result for "
+                    "step_id=%s tool=%s type=%s. Any $from_step refs to "
+                    "this step_id will fail with 'step_id not found'.",
+                    step_id, tool, type(result.result).__name__,
+                )
 
         if not result.ok and stop_on_failure:
             break

package/mcp_server/runtime/remote_commands.py

@@ -82,6 +82,12 @@ BRIDGE_COMMANDS: frozenset[str] = frozenset({
     "remove_warp_marker", "capture_audio", "capture_stop",
     "check_flucoma", "scrub_clip", "stop_scrub", "get_display_values",
     "get_plugin_params", "map_plugin_param", "get_plugin_presets",
+    # Deep-LOM writes that the Python Remote Script cannot reach (live on
+    # the sample child object or require device-selection semantics that
+    # only Max JS LiveAPI exposes). See mcp_server/tools/analyzer.py for
+    # the matching MCP tools that route through bridge.send_command.
+    "simpler_set_warp",
+    "compressor_set_sidechain",
     # NOTE: load_sample_to_simpler used to live here, but it's actually an
     # async Python MCP tool in mcp_server/tools/analyzer.py, not a bridge
     # command. It has no case in livepilot_bridge.js and no @register handler

package/mcp_server/sample_engine/models.py

@@ -139,11 +139,30 @@ class SampleFitReport:
 
     @property
     def overall_score(self) -> float:
+        """Average over AVAILABLE critics only.
+
+        BUG-B38 reshaped frequency_fit to report ``-1.0`` with
+        ``available=False`` when no mix snapshot is present. The previous
+        aggregator mean-folded that sentinel into the overall score,
+        dropping it by ~17 points (one critic out of six). The fix is to
+        respect the ``available`` flag — same contract every other caller
+        uses.
+        """
         if not self.critics:
             return 0.0
-        scores = [c.score if isinstance(c, CriticResult) else c.get("score", 0)
-                  for c in self.critics.values()]
-        return sum(scores) / len(scores) if scores else 0.0
+        available_scores = []
+        for c in self.critics.values():
+            if isinstance(c, CriticResult):
+                if c.available is False:
+                    continue
+                available_scores.append(c.score)
+            else:  # legacy dict shape
+                if c.get("available") is False:
+                    continue
+                available_scores.append(c.get("score", 0))
+        if not available_scores:
+            return 0.0
+        return sum(available_scores) / len(available_scores)
 
     def to_dict(self) -> dict:
         return {

package/mcp_server/semantic_moves/__init__.py

@@ -14,3 +14,4 @@ from . import transition_compilers  # noqa: F401
 from . import sound_design_compilers  # noqa: F401
 from . import performance_compilers  # noqa: F401
 from . import sample_compilers  # noqa: F401
+from . import device_creation_compilers  # noqa: F401

package/mcp_server/semantic_moves/compiler.py

@@ -24,14 +24,22 @@ class CompiledStep:
     params: dict                 # Concrete params, e.g. {"track_index": 0, "volume": 0.72}
     description: str             # Human-readable, e.g. "Push Drums from 0.65 → 0.72"
     verify_after: bool = True    # Whether to check meters after this step
+    # Optional explicit backend. If set, the execution router uses it verbatim
+    # and skips classify_step(). Leave None to let the router auto-classify at
+    # dispatch time — safe because test_move_annotations enforces every
+    # registered move's steps map to a known backend.
+    backend: Optional[str] = None
 
     def to_dict(self) -> dict:
-        return {
+        d = {
             "tool": self.tool,
             "params": self.params,
             "description": self.description,
             "verify_after": self.verify_after,
         }
+        if self.backend:
+            d["backend"] = self.backend
+        return d
 
 
 @dataclass

package/mcp_server/semantic_moves/device_creation_compilers.py

@@ -0,0 +1,47 @@
+"""Family compiler for device-creation semantic moves.
+
+Device-creation moves generate custom M4L devices via the Device Forge
+(``generate_m4l_effect``). Unlike mix/sound-design moves — where the
+compiler inspects the kernel's track topology — device-creation moves
+are parametric: the plan_template already contains the tool call and
+concrete arguments.
+
+We therefore use a single family-level compiler that just maps
+``plan_template`` → ``CompiledStep`` objects. This keeps the registry
+honest (every move is either compilable or analytical_only) without
+duplicating templates into per-move compilers.
+"""
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_family_compiler
+from .models import SemanticMove
+
+
+def _compile_device_creation(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Map plan_template steps straight to CompiledStep.
+
+    plan_template is trusted for this family: each step already has
+    ``tool``, ``params``, ``description``, and ``backend`` annotated.
+    """
+    steps: list[CompiledStep] = []
+    for step in move.plan_template:
+        steps.append(CompiledStep(
+            tool=step.get("tool", ""),
+            params=step.get("params", {}),
+            description=step.get("description", ""),
+            verify_after=bool(step.get("verify_after", True)),
+            backend=step.get("backend"),
+        ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        risk_level=move.risk_level,
+        summary=move.intent,
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=[],
+    )
+
+
+register_family_compiler("device_creation", _compile_device_creation)

package/mcp_server/semantic_moves/mix_compilers.py

@@ -282,6 +282,173 @@ def _compile_reduce_repetition(move: SemanticMove, kernel: dict) -> CompiledPlan
     )
 
 
+def _compile_make_kick_bass_lock(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'make_kick_bass_lock': carve space between kick and bass.
+
+    Strategy: reduce bass level slightly (clears sub for kick), verify both
+    tracks remain active. Sidechain compressor insertion is left as a future
+    step — it requires device selection + parameter mapping that varies too
+    much across projects to hardcode safely.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    bass_tracks = resolvers.find_tracks_by_role(kernel, ["bass"])
+    kick_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+
+    if not bass_tracks:
+        warnings.append("No bass track found — cannot lock kick and bass")
+    if not kick_tracks:
+        warnings.append("No kick/drum track found — reference track missing")
+
+    steps.append(CompiledStep(
+        tool="get_master_spectrum",
+        params={},
+        description="Read current sub/low balance before carving",
+        verify_after=False,
+    ))
+
+    if bass_tracks:
+        bass = bass_tracks[0]
+        idx = bass["index"]
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": idx, "volume": 0.60},
+            description=f"Pull {bass['name']} to 0.60 to clear sub for kick",
+        ))
+        descriptions.append(f"Pull {bass['name']} to 0.60")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify kick and bass both still producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_master_spectrum", "params": {}}],
+        after_reads=[
+            {"tool": "get_master_spectrum", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No kick/bass changes compiled",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_create_buildup_tension(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'create_buildup_tension': pull harmony back, raise perc energy.
+
+    We apply volume moves as the minimal, reversible tension-builder. Filter
+    rises and send ramps belong in an automation recipe — we issue a tension
+    gesture template step if the gesture engine is available, otherwise fall
+    back to direct volume changes only.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    perc_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    harmony_tracks = resolvers.find_tracks_by_role(kernel, ["chords", "pad"])
+
+    if not perc_tracks and not harmony_tracks:
+        warnings.append("No percussion or harmony tracks found — cannot build tension")
+
+    # Raise perc for energy
+    for pt in perc_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": pt["index"], "volume": 0.78},
+            description=f"Push {pt['name']} to 0.78 for rising energy",
+        ))
+        descriptions.append(f"Push {pt['name']} to 0.78")
+
+    # Pull harmony slightly to amplify perc contrast
+    for ht in harmony_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": ht["index"], "volume": 0.35},
+            description=f"Pull {ht['name']} to 0.35 to create harmonic vacuum before drop",
+        ))
+        descriptions.append(f"Pull {ht['name']} to 0.35")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify tension steps did not silence any track",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        after_reads=[
+            {"tool": "get_emotional_arc", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "No tracks to ratchet",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_smooth_scene_handoff(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'smooth_scene_handoff': reduce master volume briefly around the handoff.
+
+    Without knowing which two scenes are involved, the compiler can only do a
+    conservative energy dip using master volume. A future version should take
+    scene indices via kernel.intent_context and apply targeted crossfades.
+    """
+    steps: list[CompiledStep] = []
+    warnings: list[str] = []
+    descriptions: list[str] = []
+
+    # Minimal approach — gentle master dip the agent can reverse easily.
+    steps.append(CompiledStep(
+        tool="get_master_meters",
+        params={},
+        description="Record current master level for handoff reference",
+        verify_after=False,
+    ))
+
+    steps.append(CompiledStep(
+        tool="set_master_volume",
+        params={"volume": 0.78},
+        description="Gentle master dip for transition",
+    ))
+    descriptions.append("Master dip to 0.78")
+
+    steps.append(CompiledStep(
+        tool="get_master_meters",
+        params={},
+        description="Verify master dip applied without clipping",
+    ))
+
+    warnings.append(
+        "Scene-aware handoff (from_scene/to_scene) not yet compiled — "
+        "this is a conservative energy-dip fallback"
+    )
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        after_reads=[{"tool": "get_emotional_arc", "params": {}}],
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
 # ── Register all compilers ──────────────────────────────────────────────────
 
 register_compiler("make_punchier", _compile_make_punchier)
@@ -289,3 +456,6 @@ register_compiler("tighten_low_end", _compile_tighten_low_end)
 register_compiler("widen_stereo", _compile_widen_stereo)
 register_compiler("darken_without_losing_width", _compile_darken_mix)
 register_compiler("reduce_repetition_fatigue", _compile_reduce_repetition)
+register_compiler("make_kick_bass_lock", _compile_make_kick_bass_lock)
+register_compiler("create_buildup_tension", _compile_create_buildup_tension)
+register_compiler("smooth_scene_handoff", _compile_smooth_scene_handoff)

package/mcp_server/semantic_moves/mix_moves.py

@@ -92,7 +92,7 @@ REDUCE_REPETITION = SemanticMove(
     ],
     verification_plan=[
         {"tool": "get_track_meters", "check": "all tracks still producing audio", "backend": "remote_command"},
-        {"tool": "capture_audio", "check": "LRA > 2 LU (dynamic range should increase)", "backend": "mcp_tool"},
+        {"tool": "capture_audio", "check": "LRA > 2 LU (dynamic range should increase)", "backend": "bridge_command"},
     ],
 )
 

package/mcp_server/semantic_moves/models.py

@@ -24,6 +24,10 @@ class SemanticMove:
     plan_template: list = field(default_factory=list)  # [{tool, params, description}] — static metadata, NOT runtime truth
     verification_plan: list = field(default_factory=list)  # [{tool, check}]
     confidence: float = 0.7
+    # analytical_only: move is intentionally metadata-only — no compiler is
+    # expected. Surfaces in discovery/wonder_mode but never executes. Set this
+    # to True for moves that are deliberate "hints" rather than orphan-by-bug.
+    analytical_only: bool = False
 
     def to_dict(self) -> dict:
         return {
@@ -36,6 +40,7 @@ class SemanticMove:
             "required_capabilities": self.required_capabilities,
             "plan_template_steps": len(self.plan_template),
             "confidence": self.confidence,
+            "analytical_only": self.analytical_only,
         }
 
     def to_full_dict(self) -> dict: