livepilot 1.27.2 → 1.27.3

package/mcp_server/composer/full/engine.py

@@ -208,20 +208,46 @@ def _arrangement_steps(
     layer: LayerSpec,
     sections: list[dict],
 ) -> list[dict]:
-    """Emit the full arrangement sequence for a layer.
+    """Emit the Session-View source-clip scaffold for a layer.
 
     For each layer that appears in at least one section, we emit:
 
       1. create_clip — a 1-bar MIDI clip in session slot 0 (the source)
       2. add_notes   — a single C3 trigger note so Simpler actually sounds
-      3. create_arrangement_clip (×N) — one per section the layer is in,
-         tiling the 1-bar source across each section's bar count
-
-    The trigger-clip-plus-tile approach is intentionally minimal: Simpler
-    in classic mode plays the full sample on every note, so a single C3
-    at bar 0 is enough for a playable baseline. The suggest_sample_technique
-    step elsewhere in the plan produces a recipe the agent can use later
-    to replace the trigger pattern with something more musical.
+
+    The trigger-clip approach is intentionally minimal: Simpler in classic
+    mode plays the full sample on every note, so a single C3 at bar 0 is
+    enough for a playable, auditionable baseline in Session View. The
+    suggest_sample_technique step elsewhere in the plan produces a recipe
+    the agent can use later to replace the trigger pattern with something
+    more musical.
+
+    BUG-FULL-MODE-18 (rescoped): this used to also emit one
+    `create_arrangement_clip` per section, tiling the SAME 1-bar/single-note
+    source across every section (intro/build/drop/breakdown/outro all play
+    the identical loop). That isn't arrangement — it's pattern
+    multiplication dressed up as one, and it's worse than not placing
+    anything at all because it *looks* like a finished arrangement to a
+    caller inspecting `plan`. `ComposerEngine` is a pure-computation engine
+    with no per-section creative content generation (no LLM in the loop,
+    no per-section note variation) — that capability lives in the
+    agent-designed `apply_full_plan_v2` variant-slot system
+    (`composer/full/apply.py`), which real callers of `compose_full_apply`
+    already use instead of this deterministic engine (its own docstring
+    says as much: "Replaces the deterministic engine path that was prone
+    to flat single-pattern arrangements (BUG-FULL-MODE-18)").
+    `ComposerEngine.compose()` is reachable through a second path though —
+    `commit_experiment` → `escalate_composer_branch` — which has no agent
+    turn to design real per-section variants. Porting the variant-slot
+    system here would require synthesizing per-section musical content
+    from nothing, which is out of scope for a mechanical renumbering/
+    dead-code fix and would just relocate the same static content into
+    more slots without solving the actual "flat" complaint. So: this
+    engine now emits ONLY the Session-View scaffold (source clip + track),
+    honestly leaving Arrangement placement undone rather than faking it.
+    Callers that need real per-section arrangement variation should use
+    `compose_full_apply` (or fall back to the branch-hypothesis scaffold
+    plan, which never claimed arrangement placement in the first place).
     """
     active_sections = [s for s in sections if s["name"] in layer.sections]
     if not active_sections:
@@ -273,27 +299,6 @@ def _arrangement_steps(
         "role": layer.role,
     })
 
-    # 3. One arrangement clip per section this layer appears in
-    for section in active_sections:
-        start_bar = section["start_bar"]
-        bar_count = section["bars"]
-        steps.append({
-            "tool": "create_arrangement_clip",
-            "params": {
-                "track_index": track_index,
-                "clip_slot_index": SOURCE_SLOT,
-                "start_time": float(start_bar * 4.0),       # bars → beats
-                "length": float(bar_count * 4.0),
-                "loop_length": SOURCE_BEATS,                # tile 1-bar source
-            },
-            "description": (
-                f"Arrange {layer.role} into '{section['name']}' "
-                f"(bar {start_bar}, {bar_count} bars)"
-            ),
-            "role": layer.role,
-            "section": section["name"],
-        })
-
     return steps
 
 
@@ -354,9 +359,18 @@ class ComposerEngine:
         plan.append(_step_set_tempo(intent.tempo))
 
         # Step 2: Per-layer build, resolving samples at plan time
+        #
+        # BUG-FULL-MODE-15: track_index used to be `layer_idx` — the layer's
+        # position in the ORIGINAL (pre-drop) layer list. If an earlier layer
+        # dropped as unresolved (no continue happened for it, so no track was
+        # ever created for that index), later layers still emitted their
+        # stale original index — e.g. layers 0,3,4 survive out of 0..4, and
+        # `create_midi_track(index=3)` fails because only 1 track exists.
+        # `next_track_index` instead counts only ACTUAL track creations, so
+        # surviving layers get contiguous indices (0, 1, 2, ...) matching
+        # the tracks that really get created.
+        next_track_index = 0
         for layer_idx, layer in enumerate(layers):
-            track_index = layer_idx
-
             file_path, source = await resolve_sample_for_layer(
                 layer,
                 search_roots=search_roots,
@@ -371,6 +385,9 @@ class ComposerEngine:
                 )
                 continue
 
+            track_index = next_track_index
+            next_track_index += 1
+
             result.resolved_samples[layer.role] = {"path": file_path, "source": source}
 
             track_step_id = f"layer_{layer_idx}_track"
@@ -387,6 +404,23 @@ class ComposerEngine:
             plan.extend(_mix_steps(track_index, layer))
             plan.extend(_arrangement_steps(track_index, layer, sections))
 
+        # BUG-FULL-MODE-18 (rescoped): this engine only emits a Session-View
+        # scaffold per layer (source clip + trigger note) — it does not
+        # place anything in Arrangement, since it has no per-section
+        # creative content to place. Flag this once so callers (e.g.
+        # escalate_composer_branch) don't mistake `plan` for a finished
+        # arrangement. Real per-section arrangement variation lives in the
+        # agent-designed apply_full_plan_v2 flow (compose_full_apply).
+        if layers:
+            result.warnings.append(
+                "This scaffold places one Session-View source clip per "
+                "resolved layer and does not write anything to Arrangement "
+                "View — per-section arrangement variation is intentionally "
+                "out of scope for this deterministic engine. Use "
+                "compose_full_apply's agent-designed variant plan for real "
+                "per-section arrangement content."
+            )
+
         result.plan = plan
         return result
 

package/mcp_server/composer/tools.py

@@ -19,6 +19,7 @@ from .full.engine import ComposerEngine
 from . import fast as fast_compose
 from .fast.apply import apply_fast_plan
 from .full.apply import apply_full_plan
+import asyncio
 import logging
 import time
 
@@ -276,8 +277,8 @@ async def compose(
         return brief
 
     if mode == "fast":
-        brief = _build_fast_brief(
-            ctx, intent, bars=int(bars), reference=reference,
+        brief = await asyncio.to_thread(
+            _build_fast_brief, ctx, intent, bars=int(bars), reference=reference,
         )
         brief["prompt"] = prompt
         return brief
@@ -651,7 +652,7 @@ async def augment_with_samples(
     try:
         ableton = ctx.lifespan_context.get("ableton")
         if ableton:
-            info = ableton.send_command("get_session_info", {})
+            info = await ableton.send_command_async("get_session_info", {})
             session_context["tempo"] = info.get("tempo", 120)
             session_context["track_count"] = info.get("track_count", 0)
     except Exception as exc:

package/mcp_server/connection.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 import socket
@@ -79,9 +80,20 @@ def _identify_other_tcp_client(host: str, port: int) -> str | None:
         out = subprocess.check_output(
             ["lsof", "-nP", f"-iTCP:{port}"],
             text=True,
-            timeout=3,
+            # Bounded tight: this runs inside the send lock on a socket
+            # timeout, so a slow lsof would extend the lock-hold (blocking
+            # every concurrent tool). TimeoutExpired is a SubprocessError —
+            # NOT a CalledProcessError — so it must be caught explicitly or
+            # it propagates out of the error-diagnostic path and crashes it.
+            timeout=1,
         )
-    except (subprocess.CalledProcessError, FileNotFoundError, ValueError, OSError):
+    except (
+        subprocess.CalledProcessError,
+        subprocess.TimeoutExpired,
+        FileNotFoundError,
+        ValueError,
+        OSError,
+    ):
         return None
 
     target = f"->{host}:{port}"
@@ -119,6 +131,10 @@ class AbletonConnection:
 
     def connect(self) -> None:
         """Open a TCP connection to the Remote Script."""
+        # Close any socket we still hold before opening a new one, otherwise the
+        # previous fd/socket leaks if connect() is called without a disconnect().
+        if self._socket is not None:
+            self.disconnect()
         try:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             sock.settimeout(CONNECT_TIMEOUT)
@@ -283,12 +299,36 @@ class AbletonConnection:
             message = err.get("message", str(err)) if isinstance(err, dict) else str(err)
             log_entry["error"] = code
             self._command_log.append(log_entry)
+            # Client-eviction visibility: when this is the single-client guard
+            # rejection (this process lost the socket to another connected
+            # client — even after the retry-once path above), always try to
+            # surface WHO holds it so the user doesn't have to go hunting.
+            if _is_single_client_state_error(response):
+                other_client = _identify_other_tcp_client(self.host, self.port)
+                if other_client:
+                    message = (
+                        f"{message} Another LivePilot client appears to be "
+                        f"connected on {self.host}:{self.port} ({other_client}). "
+                        "Disconnect the other client and retry."
+                    )
             friendly = _friendly_error(code, message, command_type)
             raise AbletonConnectionError(friendly)
 
         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 :meth:`send_command`.
+
+        ``send_command`` performs a blocking TCP round-trip guarded by
+        ``self._lock``. Async MCP tools run on FastMCP's single event loop, so
+        calling ``send_command`` directly from one would freeze every other
+        concurrent coroutine (other tool calls, the UDP analyzer bridge, etc.)
+        for the duration of the round-trip. Offload it to a worker thread so
+        the loop stays free.
+        """
+        return await asyncio.to_thread(self.send_command, command_type, params)
+
     # ------------------------------------------------------------------
     # Command log
     # ------------------------------------------------------------------
@@ -340,7 +380,9 @@ class AbletonConnection:
                     err._send_completed = True
                     raise err
         except socket.timeout as exc:
-            self._recv_buf = buf
+            # Timeout is fatal to the connection: disconnect() below wipes
+            # _recv_buf to b"", so preserving the partial `buf` here would be
+            # dead, self-contradicting state. Drop it.
             self.disconnect()
             other_client = _identify_other_tcp_client(self.host, self.port)
             if other_client:
@@ -352,7 +394,7 @@ class AbletonConnection:
                 err._send_completed = True
                 raise err from exc
             err = AbletonConnectionError(
-                f"Timeout waiting for response from Ableton ({RECV_TIMEOUT}s)"
+                f"Timeout waiting for response from Ableton ({recv_timeout}s)"
             )
             err._send_completed = True
             raise err from exc
@@ -368,11 +410,27 @@ class AbletonConnection:
         line, remainder = buf.split(b"\n", 1)
         self._recv_buf = remainder
         try:
-            return json.loads(line)
-        except json.JSONDecodeError as exc:
-            raise AbletonConnectionError(
-                f"Invalid JSON from Ableton: {line[:200]}"
-            ) from exc
+            try:
+                parsed = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise AbletonConnectionError(
+                    f"Invalid JSON from Ableton: {line[:200]}"
+                ) from exc
+
+            # Correlate the response against the command we just sent. The
+            # Remote Script echoes our request id; a mismatch means we read an
+            # orphan / mis-paired frame and must not return it as this
+            # command's result.
+            resp_id = parsed.get("id") if isinstance(parsed, dict) else None
+            if resp_id is not None and resp_id != envelope["id"]:
+                self.disconnect()
+                err = AbletonConnectionError(
+                    f"Response id mismatch from Ableton "
+                    f"(expected {envelope['id']}, got {resp_id})"
+                )
+                err._send_completed = True
+                raise err
+            return parsed
         finally:
             if self._socket is not None:
                 try:

package/mcp_server/creative_constraints/engine.py

@@ -103,14 +103,22 @@ def validate_plan_against_constraints(
 
         elif constraint == "subtraction_only":
             add_actions = {"create_clip", "create_midi_track", "create_audio_track",
-                          "duplicate_clip", "duplicate_track"}
+                          "duplicate_clip", "duplicate_track",
+                          # The most common content-ADDING tools were missing, so
+                          # subtraction_only let additions through. Real tool names:
+                          "add_notes", "add_arrangement_notes", "create_scene",
+                          "duplicate_scene", "insert_simpler_slice", "add_drum_rack_pad",
+                          "create_arrangement_clip", "insert_device", "insert_rack_chain"}
             for step in steps:
                 if step.get("action", "") in add_actions:
                     violations.append(f"Step adds content ({step['action']}) — violates subtraction_only")
 
         elif constraint == "arrangement_only":
+            # NOTE: "set_track_send" is the REAL registered send tool; the old
+            # "set_send_level" is a dead name that never matched a compiled step,
+            # so send-level moves silently passed under arrangement_only.
             mix_actions = {"set_device_parameter", "set_track_volume", "set_track_pan",
-                          "set_send_level"}
+                          "set_track_send"}
             for step in steps:
                 if step.get("action", "") in mix_actions:
                     violations.append(f"Step modifies mix ({step['action']}) — violates arrangement_only")

package/mcp_server/creative_constraints/tools.py

@@ -118,16 +118,23 @@ def distill_reference_principles(
         except Exception as exc:
             logger.debug("distill_reference_principles failed: %s", exc)
 
-    # Try the built-in style profile builder
-    if not reference_profile:
+    # Try the built-in style profile builder. build_style_reference_profile
+    # takes a LIST OF TACTIC DICTS (StyleTactic.to_dict()), not a raw string —
+    # get_style_tactics resolves a NAMED style (artist/genre) to that data.
+    # Passing the bare style_name string made the builder iterate the string's
+    # characters, raise AttributeError on `char.get(...)`, and silently fall
+    # through to the text-keyword path below — so this whole branch was dead.
+    if not reference_profile and style_name:
         try:
             from ..reference_engine.profile_builder import build_style_reference_profile
-            profile = build_style_reference_profile(
-                style_name or reference_description
-            )
-            reference_profile = profile.to_dict() if profile else {}
+            from ..tools._research_engine import get_style_tactics
+            tactics = get_style_tactics(style_name)
+            tactic_dicts = [t.to_dict() for t in tactics]
+            if tactic_dicts:
+                profile = build_style_reference_profile(tactic_dicts)
+                reference_profile = profile.to_dict() if profile else {}
         except Exception as exc:
-            logger.debug("distill_reference_principles failed: %s", exc)
+            logger.debug("distill_reference_principles style-profile failed: %s", exc)
 
     # Text-keyword fallback ALWAYS merges in. Style tactics + profile
     # builder typically leave some fields empty; the description's
@@ -247,6 +254,14 @@ def generate_constrained_variants(
         # variants to status='blocked', and count blocked_count in the
         # response so callers can detect the "all variants filtered" case.
         blocked_count = 0
+        # Surface which constraints are advisory-only (recognized but NOT
+        # enforced by the filter). These depend on the constraint SET, not the
+        # plan, so compute once. Without this, a caller requesting a purely
+        # advisory constraint gets blocked_count=0 with no signal that
+        # enforcement was advisory-only.
+        constraint_meta = engine.validate_plan_against_constraints({"steps": []}, active)
+        unenforced_constraints = constraint_meta.get("unenforced_constraints", [])
+        constraint_warnings = constraint_meta.get("warnings", [])
         for v in ps.variants:
             v.what_preserved = (
                 f"{v.what_preserved} | Constraints: "
@@ -291,6 +306,8 @@ def generate_constrained_variants(
         return {
             "preview_set": ps.to_dict(),
             "constraints_applied": active.constraints,
+            "unenforced_constraints": unenforced_constraints,
+            "constraint_warnings": constraint_warnings,
             "blocked_count": blocked_count,
             "executable_count": len(ps.variants) - blocked_count,
             "note": note,

package/mcp_server/curves.py

@@ -151,9 +151,15 @@ def generate_curve(
 
     points = gen(**kwargs)
 
-    # Auto-calculate point duration if not specified
+    # Auto-calculate point duration if not specified. Use the actual spacing
+    # between consecutive points rather than duration/len(points): density
+    # generators that span the closed interval [0, duration] space points at
+    # duration/(density-1), so duration/len would under-shoot and the final
+    # step would overshoot the clip end. Reading the real gap keeps the step
+    # width consistent with however the generator placed its points.
     if point_duration <= 0 and len(points) > 1:
-        point_duration = duration / len(points)
+        spacing = points[1]["time"] - points[0]["time"]
+        point_duration = spacing if spacing > 0 else duration / len(points)
 
     # Apply transforms
     for p in points:
@@ -227,7 +233,9 @@ def _sine(duration: float, density: int, center: float, amplitude: float,
     """Periodic oscillation. frequency = cycles per duration."""
     points = []
     for i in range(density):
-        t = (i / max(density - 1, 1)) if density > 1 else 0.0
+        # Half-open interval [0, duration): never emit t == duration, which
+        # for a periodic curve duplicates the t == 0 sample at the loop seam.
+        t = i / density if density > 0 else 0.0
         angle = 2 * math.pi * frequency * t + phase * 2 * math.pi
         points.append({
             "time": t * duration,
@@ -241,7 +249,9 @@ def _sawtooth(duration: float, density: int, start: float, end: float,
     """Ramp up then reset. frequency = resets per duration."""
     points = []
     for i in range(density):
-        t = (i / max(density - 1, 1)) if density > 1 else 0.0
+        # Half-open interval [0, duration): a periodic sawtooth that emits
+        # t == duration duplicates the t == 0 sample at the loop seam.
+        t = i / density if density > 0 else 0.0
         # Position within current cycle (0.0 to 1.0)
         cycle_pos = (t * frequency) % 1.0
         points.append({
@@ -268,7 +278,9 @@ def _square(duration: float, density: int, low: float, high: float,
     """Binary on/off toggle."""
     points = []
     for i in range(density):
-        t = (i / max(density - 1, 1)) if density > 1 else 0.0
+        # Half-open interval [0, duration): a periodic gate that emits
+        # t == duration duplicates the t == 0 sample at the loop seam.
+        t = i / density if density > 0 else 0.0
         cycle_pos = (t * frequency) % 1.0
         points.append({
             "time": t * duration,
@@ -483,10 +495,16 @@ def _easing(duration: float, density: int, start: float = 0.0,
             return 7.5625 * t * t + 0.984375
 
     def _elastic(t: float) -> float:
+        # easeOutElastic: spring-like overshoot that RINGS DOWN and settles
+        # at 1.0. The old easeInElastic form held near 0 for almost the whole
+        # span then snapped to 1 at t==1 — after the [0,1] clamp in
+        # generate_curve that collapsed to a near-step function (P2-42).
+        # easeOutElastic oscillates with decaying amplitude across the span,
+        # so the characteristic ring survives the clamp.
         if t == 0 or t == 1:
             return t
-        p = 0.3
-        return -(2 ** (10 * (t - 1))) * math.sin((t - 1 - p/4) * 2 * math.pi / p)
+        c4 = (2 * math.pi) / 3
+        return 2 ** (-10 * t) * math.sin((t * 10 - 0.75) * c4) + 1.0
 
     def _back(t: float) -> float:
         s = 1.70158  # overshoot amount
@@ -539,6 +557,11 @@ def _euclidean(duration: float, density: int, start: float = 0.0,
     5 filter opens across 8 beats. 3 reverb throws across 16 steps.
     Produces non-obvious but musically satisfying rhythmic modulation.
     """
+    # Guard: steps must be >= 1 — Bjorklund on 0 slots yields an empty
+    # pattern, and dividing duration by len([]) raises ZeroDivisionError.
+    if steps < 1:
+        raise ValueError("euclidean 'steps' must be >= 1")
+
     # Bjorklund algorithm
     def _bjorklund(hits_n: int, steps_n: int) -> list:
         if hits_n >= steps_n:

package/mcp_server/device_forge/builder.py

@@ -55,22 +55,25 @@ def _make_line(src_id: str, src_outlet: int,
 
 
 def _ensure_safety_clip(code: str) -> str:
-    """Append safety clipping to gen~ code to prevent speaker damage."""
-    safe = code.rstrip()
-    if "clip(" in safe.lower():
-        return safe
+    """Clamp each gen~ output to [-1, 1] to prevent speaker damage.
 
-    # Find output assignments and wrap them
+    Each `outN = ...` assignment is clamped UNLESS that specific line already
+    clips its own output. The previous version bailed entirely when the
+    substring 'clip(' appeared ANYWHERE (a comment, an unrelated helper, or
+    clipping only ONE of several outputs), shipping the remaining outputs
+    unclamped — a real loud-output hazard on Live's master/instrument chain.
+    """
+    safe = code.rstrip()
     lines = safe.split("\n")
     new_lines = []
     for line in lines:
         stripped = line.strip()
-        if stripped.startswith("out") and "=" in stripped:
+        new_lines.append(line)
+        is_output = stripped.startswith("out") and "=" in stripped
+        already_clipped = "clip(" in stripped.lower()
+        if is_output and not already_clipped:
             var = stripped.split("=")[0].strip()
-            new_lines.append(line)
             new_lines.append(f"{var} = clip({var}, -1, 1);")
-        else:
-            new_lines.append(line)
     return "\n".join(new_lines)
 
 
@@ -214,12 +217,27 @@ def _build_audio_effect_patcher(spec: DeviceSpec) -> dict:
     # plugin~ R -> plugout~ R (direct passthrough)
     lines.append(_make_line(plugin_id, 1, plugout_id, 1))
 
-    # live.dial for each parameter
+    # live.dial for each parameter, WIRED to the gen~ param of the same name.
+    # Previously the dials had no outgoing patchline, so they were decorative —
+    # moving a knob changed no DSP. live.dial emits its float on outlet 1
+    # (outlettype ["", "float"]); routing it through [prepend <name>] produces
+    # the "<name> <value>" message that sets the matching `param <name>` object
+    # inside the gen~ sub-patcher (gen~ accepts param-set messages on inlet 0
+    # alongside the audio signal).
     for i, param in enumerate(spec.params):
         did = nid()
         x = 10.0 + i * 54.0
         boxes.append(param.to_live_dial_json(did, [x, 10.0, 44.0, 48.0]))
 
+        prepend_id = nid()
+        boxes.append(_make_box(
+            prepend_id, "newobj", f"prepend {param.name}", 1, 1, [""],
+            [x, 70.0, 90.0, 22.0],
+        ))
+        # dial float outlet (1) -> prepend -> gen~ inlet 0
+        lines.append(_make_line(did, 1, prepend_id, 0))
+        lines.append(_make_line(prepend_id, 0, gen_id, 0))
+
     # Title comment
     tid = nid()
     boxes.append({
@@ -289,12 +307,23 @@ _PATCHER_BUILDERS = {
     DeviceType.AUDIO_EFFECT: _build_audio_effect_patcher,
     DeviceType.MIDI_EFFECT: _build_midi_effect_patcher,
     DeviceType.INSTRUMENT: _build_instrument_patcher,
+    # MIDI generator / transformation are MIDI-domain devices (Live's "Max MIDI
+    # Effect" preset family — see _SUBDIR_MAP), so they share the midiin→midiout
+    # patcher. Without these entries build_patcher_json raised an uncaught
+    # KeyError for two advertised, reachable device types.
+    DeviceType.MIDI_GENERATOR: _build_midi_effect_patcher,
+    DeviceType.MIDI_TRANSFORMATION: _build_midi_effect_patcher,
 }
 
 
 def build_patcher_json(spec: DeviceSpec) -> dict:
     """Build the complete .maxpat JSON patcher dict for a device spec."""
-    return _PATCHER_BUILDERS[spec.device_type](spec)
+    builder = _PATCHER_BUILDERS.get(spec.device_type)
+    if builder is None:
+        raise ValueError(
+            f"INVALID_PARAM: no patcher builder for device_type {spec.device_type!r}"
+        )
+    return builder(spec)
 
 
 def build_amxd_binary(spec: DeviceSpec) -> bytes:

package/mcp_server/device_forge/models.py

@@ -61,6 +61,15 @@ class GenExprParam:
     unit_style: int = UNIT_STYLE_FLOAT
     exponent: float = 1.0  # 1.0 = linear
 
+    def __post_init__(self):
+        # gen~ Param names and the live.dial `prepend <name>` wiring are
+        # single-token: a name with internal whitespace ("Filter Cutoff")
+        # would emit `prepend Filter Cutoff` -> gen~ reads param "Filter" plus
+        # stray tokens and the knob silently drives no DSP. Normalize internal
+        # whitespace to underscores so both the dial wiring and the gen~ `param`
+        # declaration stay consistent (tier1a-1).
+        self.name = re.sub(r"\s+", "_", str(self.name).strip())
+
     def to_genexpr(self) -> str:
         """Generate the Param declaration for gen~ codebox."""
         return f"Param {self.name}({self.default});"

package/mcp_server/device_forge/tools.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import tempfile
 from pathlib import Path
 
@@ -48,11 +49,13 @@ async def generate_m4l_effect(
     }
     dt = type_map.get(device_type)
     if dt is None:
-        return {"error": f"Invalid device_type: {device_type}. Use: audio_effect, midi_effect, instrument"}
+        return {"error": f"INVALID_PARAM: Invalid device_type: {device_type}. Use one of: {', '.join(type_map)}"}
 
     parsed_params = []
     if params:
         for p in params:
+            if not isinstance(p, dict) or "name" not in p:
+                return {"error": f"INVALID_PARAM: each param requires a 'name' key, got: {p!r}"}
             parsed_params.append(GenExprParam(
                 name=p["name"],
                 default=p.get("default", 0.5),
@@ -72,9 +75,16 @@ async def generate_m4l_effect(
     if install:
         subdir = _SUBDIR_MAP[dt]
         output_dir = ABLETON_USER_LIBRARY / subdir
-        path = build_device(spec, output_dir=output_dir)
     else:
-        path = build_device(spec, output_dir=tempfile.mkdtemp(prefix="livepilot_forge_"))
+        # Reuse ONE forge directory under the system temp instead of spawning a
+        # fresh mkdtemp() per call (those accumulated, never cleaned). The .amxd
+        # is the returned deliverable so it must persist for the caller.
+        output_dir = Path(tempfile.gettempdir()) / "livepilot_forge"
+
+    # build_device does blocking filesystem I/O (mkdir + write_bytes). This is
+    # an async tool running on the event loop, so offload to a worker thread to
+    # avoid freezing all other handlers + the bridge UDP endpoint.
+    path = await asyncio.to_thread(build_device, spec, output_dir)
 
     return {
         "status": "created",
@@ -113,15 +123,11 @@ async def list_genexpr_templates(
     }
 
 
-@mcp.tool()
-async def install_m4l_device(
-    ctx: Context,
-    source_path: str,
-) -> dict:
-    """Copy a .amxd file to Ableton's User Library.
+def _install_m4l_device_sync(source_path: str) -> dict:
+    """Blocking filesystem work for install_m4l_device (read/mkdir/write).
 
-    Args:
-        source_path: Path to the .amxd file to install
+    Run via asyncio.to_thread from the async tool below so the event loop
+    (and the bridge UDP endpoint) never stalls on disk I/O.
     """
     src = Path(source_path)
     if not src.exists():
@@ -160,3 +166,16 @@ async def install_m4l_device(
         "path": str(dest),
         "hint": "Device now available in Ableton's browser.",
     }
+
+
+@mcp.tool()
+async def install_m4l_device(
+    ctx: Context,
+    source_path: str,
+) -> dict:
+    """Copy a .amxd file to Ableton's User Library.
+
+    Args:
+        source_path: Path to the .amxd file to install
+    """
+    return await asyncio.to_thread(_install_m4l_device_sync, source_path)