livepilot 1.27.0 → 1.27.2

package/mcp_server/splice_client/models.py

@@ -185,10 +185,14 @@ class SpliceSample:
     def is_free(self) -> bool:
         """True iff this sample costs no credits under any plan.
 
-        Splice marks samples as free via `IsPremium == False` or `Price == 0`.
-        This is orthogonal to plan: even a free-tier user can license these.
+        `IsPremium` is Splice's authoritative free flag and is always
+        populated in the proto. `Price` is NOT reliable: proto3 ints
+        default to 0 when the server omits the field, so OR-ing in
+        `price == 0` would misclassify premium samples (whose Price is
+        unset/zero) as free and bypass ALL credit/quota gating. Trust
+        only `IsPremium`.
         """
-        return (not self.is_premium) or self.price == 0
+        return not self.is_premium
 
     def to_dict(self) -> dict:
         return {

package/mcp_server/synthesis_brain/adapters/analog.py

@@ -9,9 +9,12 @@ detune/unison variants and dual-filter variants.
 from __future__ import annotations
 
 import hashlib
+import logging
 from typing import Optional
 
 from ...branches import BranchSeed, freeform_seed
+
+logger = logging.getLogger(__name__)
 from ..models import (
     SynthProfile,
     TimbralFingerprint,
@@ -115,7 +118,16 @@ class AnalogAdapter:
             try:
                 maybe = strategy_fn(profile, target, kernel, adapter=self)
             except Exception:
-                # Never let one strategy's crash kill the rest.
+                # Never let one strategy's crash kill the rest, but make the
+                # swallowed failure observable instead of silently degrading
+                # the branch set.
+                logger.warning(
+                    "Analog strategy %s crashed on track %s device %s; skipping",
+                    getattr(strategy_fn, "__name__", strategy_fn),
+                    profile.track_index,
+                    profile.device_index,
+                    exc_info=True,
+                )
                 continue
             if maybe is not None:
                 results.append(maybe)

package/mcp_server/synthesis_brain/adapters/operator.py

@@ -103,8 +103,11 @@ def _pick_target_modulator(
         return None
     candidates.sort(reverse=True)  # highest level first
     top_level, top_op = candidates[0]
-    # If every modulator is silent, still return the first one — the shift
-    # primes the patch for a future Level bump. Better than no branch.
+    # If every modulator is silent (Level <= 0), shifting its Coarse produces
+    # no audible change. Return None so the caller falls through to
+    # _fallback_carrier_target and targets an audible carrier instead.
+    if top_level <= 0.0:
+        return None
     return top_op
 
 

package/mcp_server/synthesis_brain/adapters/wavetable.py

@@ -48,8 +48,8 @@ from .base import register_adapter
 # corpus (see skills/livepilot-core/references/device-knowledge/
 # instruments-synths.md). PR9 uses a small subset; later PRs extend.
 _KNOWN_PARAMS = {
-    "Osc 1 Position",
-    "Osc 2 Position",
+    "Osc 1 Pos",
+    "Osc 2 Pos",
     "Osc 1 Transpose",
     "Osc 2 Transpose",
     "Voices",
@@ -220,7 +220,7 @@ class WavetableAdapter:
         # shift to that region's center. The actual shift magnitude
         # (how close to the center) scales with freshness — low
         # freshness stops partway, high freshness commits fully.
-        current_pos = float(profile.parameter_state.get("Osc 1 Position", 0.0) or 0.0)
+        current_pos = float(profile.parameter_state.get("Osc 1 Pos", 0.0) or 0.0)
         current_region = _classify_position(current_pos)
         target_region = _choose_target_region(current_region, target)
         region_target_pos = _region_center(target_region)
@@ -281,7 +281,7 @@ class WavetableAdapter:
                     "params": {
                         "track_index": track,
                         "device_index": device,
-                        "parameter_name": "Osc 1 Position",
+                        "parameter_name": "Osc 1 Pos",
                         "value": new_pos,
                     },
                 },

package/mcp_server/tools/_composition_engine/models.py

@@ -62,6 +62,12 @@ class SectionNode:
     density: float  # 0.0-1.0 (how many tracks are active)
     tracks_active: list[int] = field(default_factory=list)
     name: str = ""
+    # Real session scene/row index this section maps to (the clip slot to
+    # read notes from). -1 means "not scene-backed" (e.g. built from the
+    # arrangement view), in which case callers should fall back to the
+    # section's position in the graph. Kept last so existing positional
+    # SectionNode(...) constructions stay valid.
+    scene_index: int = -1
 
     def length_bars(self) -> int:
         return self.end_bar - self.start_bar

package/mcp_server/tools/_composition_engine/sections.py

@@ -112,6 +112,10 @@ def build_section_graph_from_scenes(
             density=density,
             tracks_active=active_tracks,
             name=scene_name,
+            # Real session scene row — used as the get_notes clip_index.
+            # Differs from the section's position in this list whenever
+            # earlier unnamed/empty scenes were skipped above.
+            scene_index=i,
         ))
         current_bar = end_bar
 

package/mcp_server/tools/clips.py

@@ -380,9 +380,10 @@ async def check_clip_key_consistency(
     # 1) Resolve the clip's file path. Relies on the M4L bridge.
     try:
         from .analyzer import get_clip_file_path as _get_path
-        # get_clip_file_path is an @mcp.tool, but FastMCP decorators preserve
-        # the underlying function — we can call it directly for composition.
-        path_resp = await _get_path.fn(ctx, track_index, clip_index)
+        # Under FastMCP 3.3.1 @mcp.tool() returns the plain async function
+        # (no .fn accessor), so we call it directly for composition — the
+        # same pattern analyzer.verify_all_devices_health uses.
+        path_resp = await _get_path(ctx, track_index, clip_index)
     except Exception as exc:
         return {
             "track_index": track_index,
@@ -414,7 +415,7 @@ async def check_clip_key_consistency(
     # 3) Query the session-detected key (needs the analyzer).
     try:
         from .analyzer import get_detected_key as _get_key
-        key_resp = await _get_key.fn(ctx)
+        key_resp = await _get_key(ctx)
     except Exception as exc:
         return {
             "track_index": track_index,

package/mcp_server/tools/composition.py

@@ -408,12 +408,16 @@ def get_harmony_field(
                    for i, t in enumerate(tracks)}
 
     # Per-track scan: fetch notes + score, then sort by score desc.
+    # Use the section's real scene row (scene_index) for the clip slot,
+    # not section_index (its position in the section graph) — these
+    # diverge whenever earlier unnamed/empty scenes were skipped.
+    scene_idx = section.scene_index if getattr(section, "scene_index", -1) >= 0 else section_index
     HARMONIC_THRESHOLD = 0.3
     candidates: list[tuple[float, int, list[dict]]] = []
     for t_idx in section.tracks_active:
         try:
             result = ableton.send_command("get_notes", {
-                "track_index": t_idx, "clip_index": section_index,
+                "track_index": t_idx, "clip_index": scene_idx,
             })
         except Exception as exc:
             logger.debug("harmony scan track %d: %s", t_idx, exc)

package/mcp_server/tools/midi_io.py

@@ -34,6 +34,12 @@ def _require_midiutil():
         )
 
 
+# Hard cap on extract_piano_roll's emitted matrix (pitch_range * time_steps).
+# ~16k cells keeps the JSON response well inside a single context window even
+# for a full 88-key range; coarsen 'resolution' to fit larger material.
+_PIANO_ROLL_CELL_BUDGET = 16000
+
+
 def _require_pretty_midi():
     try:
         import pretty_midi
@@ -348,7 +354,20 @@ def extract_piano_roll(
 
     Returns a velocity matrix [pitch_index][time_step] trimmed to
     the actual pitch range. Resolution is in beats (0.125 = 32nd note).
+
+    To keep the response bounded, the emitted matrix is capped at
+    ``_PIANO_ROLL_CELL_BUDGET`` cells (pitch_range * time_steps). When the
+    full roll exceeds the budget the tool returns a structured error with the
+    offending dimensions instead of a multi-MB matrix; coarsen ``resolution``
+    (larger value = fewer time steps) to fit.
     """
+    if not resolution or resolution <= 0:
+        return {
+            "error": "resolution must be a positive number of beats per step "
+                     f"(got {resolution!r}); e.g. 0.125 for 32nd notes.",
+            "code": "INVALID_PARAM",
+        }
+
     pretty_midi = _require_pretty_midi()
     path = _validate_midi_path(file_path)
     pm = pretty_midi.PrettyMIDI(str(path))
@@ -373,10 +392,30 @@ def extract_piano_roll(
     pitch_max = int(active_pitches[-1])
     trimmed = roll[pitch_min:pitch_max + 1, :]
 
+    pitch_range = int(trimmed.shape[0])
+    time_steps = int(trimmed.shape[1])
+    cell_count = pitch_range * time_steps
+    if cell_count > _PIANO_ROLL_CELL_BUDGET:
+        return {
+            "error": (
+                f"piano roll too large: {pitch_range} pitches x {time_steps} "
+                f"steps = {cell_count} cells exceeds the {_PIANO_ROLL_CELL_BUDGET}"
+                "-cell budget. Increase 'resolution' (e.g. 0.25 or 0.5 beats) "
+                "to coarsen the time axis."
+            ),
+            "code": "INVALID_PARAM",
+            "pitch_min": pitch_min,
+            "pitch_max": pitch_max,
+            "pitch_range": pitch_range,
+            "time_steps": time_steps,
+            "cell_budget": _PIANO_ROLL_CELL_BUDGET,
+            "resolution": resolution,
+        }
+
     return {
         "piano_roll": trimmed.astype(int).tolist(),
         "pitch_min": pitch_min,
         "pitch_max": pitch_max,
-        "time_steps": int(trimmed.shape[1]),
+        "time_steps": time_steps,
         "resolution": resolution,
     }

package/mcp_server/tools/transport.py

@@ -167,7 +167,7 @@ async def get_session_diagnostics(ctx: Context, check_clip_keys: bool = False) -
         # reasonable upper bound for typical production sessions.
         for clip_idx in range(min(32, len(session_info.get("scenes", []) or []) or 8)):
             try:
-                check = await check_clip_key_consistency.fn(ctx, t_idx, clip_idx)
+                check = await check_clip_key_consistency(ctx, t_idx, clip_idx)
             except Exception:  # noqa: BLE001 — any failure means "skip this clip"
                 continue
             if not isinstance(check, dict):

package/mcp_server/user_corpus/plugin_engine/detector.py

@@ -105,6 +105,62 @@ class DetectedPlugin:
 # ─── Top-level entry ────────────────────────────────────────────────────────
 
 
+# Bundle file/dir extensions per plugin format. VST3/AU/AAX/LV2 bundles are
+# themselves directories (Foo.vst3/Contents/...), so the recursive scan treats
+# a matching entry as a leaf — it records it but never descends inside.
+_BUNDLE_EXTS: dict[str, tuple[str, ...]] = {
+    "VST3": (".vst3",),
+    "AU": (".component",),
+    "VST2": (".vst", ".dylib"),
+    "AAX": (".aaxplugin",),
+    "LV2": (".lv2",),
+}
+
+
+def _is_plugin_bundle(path: Path, fmt: str) -> bool:
+    """True when *path* is itself a plugin bundle/file for *fmt* (a leaf to
+    record) rather than a vendor/organisational subfolder to recurse into."""
+    return path.suffix in _BUNDLE_EXTS.get(fmt, ())
+
+
+def _walk_plugin_bundles(root: Path, fmt: str, max_depth: int = 8):
+    """Yield every *fmt* plugin bundle/file under *root*, recursing into plain
+    (vendor) subdirectories but NOT descending into bundle directories.
+
+    Fixes the flat scan that only saw top-level bundles: plugins nested in
+    vendor subfolders (e.g. VST3/Arturia/Analog Lab.vst3) were invisible, and
+    the vendor folders themselves were mis-emitted as junk 'unknown-*' records.
+    Symlink cycles are guarded via resolved-path dedup; recursion depth is
+    capped; unreadable directories are skipped with a warning.
+    """
+    seen_dirs: set[Path] = set()
+    stack: list[tuple[Path, int]] = [(root, 0)]
+    while stack:
+        current, depth = stack.pop()
+        try:
+            real = current.resolve()
+        except OSError:
+            continue
+        if real in seen_dirs:
+            continue
+        seen_dirs.add(real)
+        try:
+            entries = sorted(current.iterdir())
+        except (PermissionError, OSError) as e:
+            logger.warning("Cannot read %s: %s", current, e)
+            continue
+        for entry in entries:
+            if _is_plugin_bundle(entry, fmt):
+                yield entry  # leaf — never descend into a bundle
+            elif depth < max_depth:
+                try:
+                    descend = entry.is_dir()
+                except OSError:
+                    descend = False
+                if descend:
+                    stack.append((entry, depth + 1))
+
+
 def detect_installed_plugins(
     paths: list[tuple[Path, str]] | None = None,
     formats: list[str] | None = None,
@@ -138,20 +194,19 @@ def detect_installed_plugins(
     results: list[DetectedPlugin] = []
     seen_keys: set[tuple[str, str, str]] = set()   # (vendor_lc, name_lc, format)
 
-    # 1. Path-based scan — covers VST3 / VST2 / AAX / LV2 + co-located AU v2
+    # 1. Path-based scan — covers VST3 / VST2 / AAX / LV2 + co-located AU v2.
+    #    Recurses into vendor subfolders (e.g. VST3/Arturia/Foo.vst3) but never
+    #    descends into bundle directories themselves. See _walk_plugin_bundles.
     for root, fmt in paths:
         if not root.exists():
             continue
-        try:
-            for entry in sorted(root.iterdir()):
-                plugin = _identify_plugin(entry, fmt)
-                if plugin:
-                    key = ((plugin.vendor or "").lower(), plugin.name.lower(), plugin.format)
-                    if key not in seen_keys:
-                        seen_keys.add(key)
-                        results.append(plugin)
-        except (PermissionError, OSError) as e:
-            logger.warning("Cannot read %s: %s", root, e)
+        for entry in _walk_plugin_bundles(root, fmt):
+            plugin = _identify_plugin(entry, fmt)
+            if plugin:
+                key = ((plugin.vendor or "").lower(), plugin.name.lower(), plugin.format)
+                if key not in seen_keys:
+                    seen_keys.add(key)
+                    results.append(plugin)
 
     # 2. auval-based AU enumeration — captures AUv3 + arbitrary-location AUs
     want_au = formats is None or "AU" in (formats or [])

package/mcp_server/user_corpus/runner.py

@@ -11,6 +11,7 @@ mtime-based incremental skipping is on by default.
 
 from __future__ import annotations
 
+import fnmatch
 import hashlib
 import json
 import logging
@@ -181,7 +182,12 @@ def _iter_files(
             continue
         if not scanner.is_applicable(p):
             continue
-        if any(p.match(g) for g in excludes):
+        # Honor excludes against BOTH the filename (Path.match, right-anchored —
+        # keeps filename-glob patterns like "*.tmp" working) and the full path
+        # string (fnmatch — lets directory patterns like "*Backup*" exclude
+        # files *inside* a Backup/ folder, which Path.match alone cannot do).
+        path_str = p.as_posix()
+        if any(p.match(g) or fnmatch.fnmatch(path_str, g) for g in excludes):
             continue
         yield p
 

package/mcp_server/user_corpus/scanners/amxd.py

@@ -143,17 +143,26 @@ class AmxdScanner(Scanner):
 # ─── Parsing ─────────────────────────────────────────────────────────────────
 
 
-# The ampf header carries device type as an ASCII letter at offset 8:
-#   'a' (97) = audio effect
-#   'i' (105) = instrument
-#   'm' (109) = MIDI effect
+# The ampf header carries device type as a 4-byte ASCII tag at offset 8:
+#   'aaaa' = audio effect
+#   'iiii' = instrument
+#   'mmmm' = MIDI effect
+#   'nagg' = MIDI Tool generator      (Live 12.1+)
+#   'natt' = MIDI Tool transformation (Live 12.1+)
 # Earlier guess of 0/1/2 was wrong — verified against the user's 393-file
 # real-world .amxd corpus where 388/393 devices reported as unknown-{97,109,105}.
+# The single-letter map predates the MIDI Tool surface: both MIDI Tool kinds
+# share first byte 'n' (110), so a single-byte read mis-tagged them as
+# unknown-110 and could not tell generator from transformation. Keying off the
+# full 4-byte tag (raw[8:12]) fixes both. The first-byte fallback preserves the
+# legacy unknown-{byte} shape for any tag we don't recognise.
 _AMPF_DEVICE_TYPE_BYTE = 8
-_DEVICE_TYPE_MAP = {
-    ord("a"): "audio",
-    ord("i"): "instrument",
-    ord("m"): "midi",
+_DEVICE_TYPE_TAG_MAP = {
+    b"aaaa": "audio",
+    b"iiii": "instrument",
+    b"mmmm": "midi",
+    b"nagg": "midi_tool_generator",
+    b"natt": "midi_tool_transformation",
 }
 
 
@@ -174,11 +183,13 @@ def _parse_amxd(raw: bytes, filename: str) -> dict:
 
     # 1. Device type from the ampf header
     if len(raw) > 24 and raw[:4] == b"ampf":
-        try:
-            tb = raw[_AMPF_DEVICE_TYPE_BYTE]
-            out["device_type"] = _DEVICE_TYPE_MAP.get(tb, f"unknown-{tb}")
-        except IndexError:
-            pass
+        tag = raw[_AMPF_DEVICE_TYPE_BYTE:_AMPF_DEVICE_TYPE_BYTE + 4]
+        known = _DEVICE_TYPE_TAG_MAP.get(tag)
+        if known is not None:
+            out["device_type"] = known
+        else:
+            # Fall back to the legacy single-byte unknown-{byte} shape.
+            out["device_type"] = f"unknown-{tag[0]}" if tag else None
 
     # 2. Locate + parse the JSON patcher block
     json_blob = _extract_patcher_json(raw)

package/mcp_server/user_corpus/tools.py

@@ -50,6 +50,20 @@ from .plugin_engine.research import (
 )
 
 
+# ─── Inline plugin serialization helper ────────────────────────────────────────
+# corpus_detect_plugins persists the FULL plugin dict (incl. raw sdk_metadata =
+# entire moduleinfo.json / Info.plist) to _inventory.json. The inline MCP
+# response, however, only needs lightweight identity fields — returning the full
+# sdk_metadata for every plugin bloats the payload and duplicates the file.
+# Callers that need the raw metadata read it back from _inventory.json.
+
+
+def _slim_plugin(plugin_dict: dict) -> dict:
+    """Return a copy of a serialized DetectedPlugin without the heavy
+    ``sdk_metadata`` blob, for inline (non-persisted) MCP responses."""
+    return {k: v for k, v in plugin_dict.items() if k != "sdk_metadata"}
+
+
 # ─── Vendor canonicalization helpers (used by corpus_canonicalize_plugins) ───
 # Strips common vendor-suffix words ("DSP", "LLC", "GmbH", etc.) so different
 # spellings of the same vendor ("Valhalla DSP, LLC" + "Valhalladsp") collapse
@@ -390,7 +404,7 @@ def corpus_detect_plugins(
         )
 
     return {
-        "plugins": plugins_serialized,
+        "plugins": [_slim_plugin(p) for p in plugins_serialized],
         "totals": {"all": len(detected), "by_format": by_format},
         "inventory_path": str(inventory_path) if inventory_path else None,
         "search_paths": [str(p) for p, _ in default_plugin_dir()],
@@ -821,6 +835,7 @@ def corpus_research_targets(
 def corpus_emit_synthesis_briefs(
     ctx: Context,
     plugin_ids: list = None,
+    inline_limit: int = 5,
 ) -> dict:
     """Phase 4 — emit sonnet-subagent briefs for plugin identity synthesis.
 
@@ -832,10 +847,18 @@ def corpus_emit_synthesis_briefs(
     ----------
     plugin_ids : list of plugin_ids to emit briefs for. If empty, emits for
                  every plugin in the inventory.
+    inline_limit : maximum number of FULL briefs returned inline (default 5,
+                 matching the 'Cap parallel subagents at ~5' instruction).
+                 Any plugins beyond this cap are returned as lightweight stubs
+                 ({plugin_id, output_path}) in `deferred` so a single call can
+                 never return a multi-MB response over a large inventory. Pass
+                 explicit `plugin_ids` (or a larger inline_limit) to get the
+                 full brief for a specific batch.
 
     Returns
     -------
-    {briefs: [{plugin_id, brief, output_path}, ...], total}
+    {briefs: [{plugin_id, brief, output_path}, ...], deferred: [{plugin_id,
+     output_path}, ...], total, inline_count, inline_limit}
     """
     inventory_path = DEFAULT_OUTPUT_ROOT / "plugins" / "_inventory.json"
     if not inventory_path.exists():
@@ -844,7 +867,9 @@ def corpus_emit_synthesis_briefs(
     all_plugins = inventory.get("plugins", [])
 
     target_ids = set(plugin_ids) if plugin_ids else None
+    cap = inline_limit if inline_limit and inline_limit > 0 else 5
     briefs = []
+    deferred = []
     for plugin_dict in all_plugins:
         pid = plugin_dict.get("plugin_id")
         if target_ids is not None and pid not in target_ids:
@@ -866,21 +891,32 @@ def corpus_emit_synthesis_briefs(
         research_root = DEFAULT_OUTPUT_ROOT / "plugins" / pid / "research"
 
         brief = build_synthesis_brief(plugin, local_manual, research_root if research_root.exists() else None)
-        briefs.append({
-            "plugin_id": pid,
-            "brief": brief,
-            "output_path": brief["output_path"],
-        })
+        if len(briefs) < cap:
+            briefs.append({
+                "plugin_id": pid,
+                "brief": brief,
+                "output_path": brief["output_path"],
+            })
+        else:
+            deferred.append({
+                "plugin_id": pid,
+                "output_path": brief["output_path"],
+            })
 
     return {
         "briefs": briefs,
-        "total": len(briefs),
+        "deferred": deferred,
+        "total": len(briefs) + len(deferred),
+        "inline_count": len(briefs),
+        "inline_limit": cap,
         "instruction": (
             "For each brief: dispatch one sonnet subagent (Agent tool with "
             "subagent_type='general-purpose', model='sonnet') passing the brief "
             "as context. The subagent reads brief['synthesis_inputs'] and writes "
             "the YAML at brief['output_path']. Cap parallel subagents at ~5 to "
-            "avoid main-context bloat."
+            "avoid main-context bloat. Plugins beyond inline_limit are listed in "
+            "'deferred' as stubs — re-call corpus_emit_synthesis_briefs with their "
+            "plugin_ids to get the full briefs for the next batch."
         ),
     }