livepilot 1.27.0 → 1.27.1

package/mcp_server/sample_engine/critics.py

@@ -301,9 +301,13 @@ def run_vibe_fit_critic(
             recommendation="No taste evidence yet — neutral score",
         )
 
-    # Compute energy proxy from sample characteristics (0.0 - 1.0)
-    # brightness and transient_density are both 0.0-1.0 range
-    energy = (profile.brightness + profile.transient_density) / 2.0
+    # Compute energy proxy from sample characteristics (0.0 - 1.0).
+    # brightness is already a 0.0-1.0 fraction, but transient_density is peaks
+    # PER SECOND (unbounded). Normalize it through a saturating curve before
+    # averaging so a busy break does not pin the proxy to 1.0 for every sample.
+    # ~12 peaks/s (busy 16ths) maps to ~1.0.
+    transient_norm = max(0.0, min(1.0, profile.transient_density / 12.0))
+    energy = (profile.brightness + transient_norm) / 2.0
     energy = max(0.0, min(1.0, energy))
 
     # Compare against novelty_band as taste proxy

package/mcp_server/sample_engine/slice_workflow.py

@@ -12,8 +12,9 @@ from __future__ import annotations
 
 import hashlib
 
-# Simpler maps slices to MIDI notes starting at C3 (60)
-SLICE_BASE_NOTE = 60
+# Simpler maps slices to MIDI notes starting at C1 (36): slice N -> pitch 36+N.
+# Notes at 60+ (C3) trigger no slice and produce silence.
+SLICE_BASE_NOTE = 36
 
 
 def plan_slice_steps(

package/mcp_server/sample_engine/tools.py

@@ -6,6 +6,7 @@ direct Splice online catalog hunt/download via the gRPC client.
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import os
 from typing import Optional
@@ -57,7 +58,11 @@ async def analyze_sample(
         return {"error": "Could not determine file path — provide file_path directly"}
 
     source = "session_clip" if track_index is not None else "filesystem"
-    profile = build_profile_from_filename(file_path, source=source)
+    # Offload audio decode + numpy FFT off the event loop (heavy CPU/IO).
+    loop = asyncio.get_running_loop()
+    profile = await loop.run_in_executor(
+        None, build_profile_from_filename, file_path, source
+    )
     return profile.to_dict()
 
 
@@ -86,6 +91,11 @@ def evaluate_sample_fit(
     song_key = None
     session_tempo = 120.0
     existing_roles: list[str] = []
+    # Map track index -> name so the key-detection loop below can look a
+    # track's name up by its real index. existing_roles is a *packed*
+    # list (unnamed/errored tracks are skipped), so indexing it by track
+    # index misaligns names with the clip that produced the notes.
+    track_names_by_index: dict[int, str] = {}
 
     try:
         ableton = ctx.lifespan_context["ableton"]
@@ -100,6 +110,7 @@ def evaluate_sample_fit(
                 name = track_info.get("name", "").lower()
                 if name:
                     existing_roles.append(name)
+                    track_names_by_index[i] = name
             except Exception as exc:
                 logger.debug("get_track_info(%d) skipped: %s", i, exc)
                 continue
@@ -147,9 +158,7 @@ def evaluate_sample_fit(
                 ) else []
                 if not notes:
                     continue
-                track_name = (
-                    existing_roles[i] if i < len(existing_roles) else ""
-                )
+                track_name = track_names_by_index.get(i, "")
                 if harmonic_score(notes, track_name) >= 0.3:
                     harmonic_pool.extend(notes)
 
@@ -189,7 +198,11 @@ def evaluate_sample_fit(
         recommended_intent=intent,
         surgeon_plan=surgeon_plan,
         alchemist_plan=alchemist_plan,
-        warnings=[c.recommendation for c in critics.values() if c.score < 0.5],
+        warnings=[
+            c.recommendation
+            for c in critics.values()
+            if getattr(c, "available", True) and c.score < 0.5
+        ],
     )
     return report.to_dict()
 
@@ -316,12 +329,16 @@ async def search_samples(
         if not used_grpc:
             splice = SpliceSource()
             if splice.enabled:
-                splice_results = splice.search(
-                    query=query,
-                    max_results=max_results,
-                    key=key,
-                    bpm_min=bpm_min,
-                    bpm_max=bpm_max,
+                # Offload blocking SQLite query off the event loop.
+                splice_results = await asyncio.get_running_loop().run_in_executor(
+                    None,
+                    lambda: splice.search(
+                        query=query,
+                        max_results=max_results,
+                        key=key,
+                        bpm_min=bpm_min,
+                        bpm_max=bpm_max,
+                    ),
                 )
                 for candidate in splice_results:
                     d = candidate.to_dict()
@@ -335,12 +352,16 @@ async def search_samples(
             browser = BrowserSource()
             for category in browser.DEFAULT_CATEGORIES:
                 try:
-                    search_result = ableton.send_command("search_browser", {
-                        "path": category,
-                        "name_filter": query,
-                        "loadable_only": True,
-                        "max_results": max_results,
-                    })
+                    # Offload blocking TCP round-trip off the event loop.
+                    search_result = await asyncio.get_running_loop().run_in_executor(
+                        None,
+                        lambda: ableton.send_command("search_browser", {
+                            "path": category,
+                            "name_filter": query,
+                            "loadable_only": True,
+                            "max_results": max_results,
+                        }),
+                    )
                     raw = search_result.get("results", [])
                     parsed = browser.parse_results(raw, category)
                     for candidate in parsed:
@@ -359,7 +380,10 @@ async def search_samples(
             "~/Music", "~/Documents/Samples",
             "~/Documents/LivePilot/downloads",
         ])
-        fs_results = fs.search(query, max_results=max_results)
+        # Offload blocking recursive filesystem scan off the event loop.
+        fs_results = await asyncio.get_running_loop().run_in_executor(
+            None, lambda: fs.search(query, max_results=max_results)
+        )
         for candidate in fs_results:
             d = candidate.to_dict()
             d["source_priority"] = 3
@@ -1049,10 +1073,18 @@ async def splice_download_sample(
     if copy_to_user_library:
         dest_dir = os.path.expanduser(_SPLICE_USER_LIB_DEST)
         try:
-            os.makedirs(dest_dir, exist_ok=True)
             dest_path = os.path.join(dest_dir, os.path.basename(local_path))
-            if not os.path.exists(dest_path):
-                shutil.copy2(local_path, dest_path)
+
+            def _copy_into_user_library():
+                os.makedirs(dest_dir, exist_ok=True)
+                if not os.path.exists(dest_path):
+                    shutil.copy2(local_path, dest_path)
+
+            # Offload the blocking filesystem copy off the event loop,
+            # mirroring the run_in_executor used in splice_preview_sample.
+            await asyncio.get_running_loop().run_in_executor(
+                None, _copy_into_user_library
+            )
             response["user_library_path"] = dest_path
             # URI format Ableton uses for user_library samples
             response["browser_uri"] = (

package/mcp_server/song_brain/builder.py

@@ -566,7 +566,23 @@ def detect_identity_drift(
         drift.drift_score += 0.2 * len(lost)
 
     # Energy arc shift
-    if before.energy_arc and after.energy_arc:
+    # Align on section_id rather than list position: inserting/removing/
+    # renaming-to-empty a scene shifts energy_arc indices (the BUG-B12 skip
+    # drops empty sections), so a positional diff fabricates drift on every
+    # section after the change. Diffing the shared section_ids compares like
+    # with like and is stable under reordering/insertion.
+    before_energy = {s.section_id: s.energy_level for s in before.section_purposes}
+    after_energy = {s.section_id: s.energy_level for s in after.section_purposes}
+    shared_ids = before_energy.keys() & after_energy.keys()
+    if shared_ids:
+        diff = sum(
+            abs(before_energy[sid] - after_energy[sid]) for sid in shared_ids
+        ) / len(shared_ids)
+        drift.energy_arc_shift = round(diff, 3)
+        drift.drift_score += diff * 0.2
+    elif before.energy_arc and after.energy_arc:
+        # Fallback for snapshots that carry energy_arc but no section_purposes
+        # (e.g. older brains): keep the legacy positional comparison.
         min_len = min(len(before.energy_arc), len(after.energy_arc))
         if min_len > 0:
             diff = sum(

package/mcp_server/sound_design/tools.py

@@ -408,7 +408,7 @@ def _cross_engine_hint_for_track(
         return None
     track_issues = [
         i for i in mix_issues
-        if getattr(i, "track_index", None) == track_index
+        if track_index in (getattr(i, "affected_tracks", []) or [])
     ]
     if not track_issues:
         return None

package/mcp_server/splice_client/http_bridge.py

@@ -45,6 +45,7 @@ import logging
 import os
 import ssl
 import urllib.error
+import urllib.parse
 import urllib.request
 from dataclasses import dataclass, field
 from typing import Any, Optional
@@ -89,6 +90,10 @@ class SpliceHTTPConfig:
     user_agent: str = "LivePilot/1.16 (+splice-http-bridge)"
     timeout_sec: float = 30.0
     max_retries: int = 2
+    # Opt-in escape hatch: when True, the bearer-token host guard in
+    # SpliceHTTPBridge._request is bypassed so a custom (non-splice.com)
+    # base_url may receive the session token. Defaults off.
+    allow_unverified_endpoints: bool = False
     # Whether any of the above values came from user config (file or env)
     # rather than the built-in defaults. Used by `is_user_configured`.
     _user_configured: bool = False
@@ -135,6 +140,7 @@ class SpliceHTTPConfig:
                                     "splice.json: %s must be an integer", key,
                                 )
                     if data.get("allow_unverified_endpoints"):
+                        instance.allow_unverified_endpoints = True
                         loaded_from_file = True
             except (OSError, json.JSONDecodeError) as exc:
                 logger.warning(
@@ -161,6 +167,9 @@ class SpliceHTTPConfig:
                         "Env %s has invalid value: %s", env_name, exc,
                     )
 
+        if os.environ.get("SPLICE_ALLOW_UNVERIFIED_ENDPOINTS") == "1":
+            instance.allow_unverified_endpoints = True
+
         instance._user_configured = (
             loaded_from_file
             or env_configured
@@ -406,6 +415,23 @@ class SpliceHTTPError(Exception):
         }
 
 
+def _is_trusted_splice_host(url: str) -> bool:
+    """True only for HTTPS URLs on a splice.com-owned host.
+
+    Gates attaching the rotating session bearer token: a poisoned base_url
+    (custom config file or SPLICE_API_BASE_URL env) must not be able to
+    exfiltrate the token to an attacker-controlled endpoint.
+    """
+    try:
+        parsed = urllib.parse.urlparse(url)
+    except (ValueError, AttributeError):
+        return False
+    if parsed.scheme != "https":
+        return False
+    host = (parsed.hostname or "").lower()
+    return host == "splice.com" or host.endswith(".splice.com")
+
+
 class SpliceHTTPBridge:
     """Low-level HTTPS client for Splice cloud APIs.
 
@@ -442,10 +468,26 @@ class SpliceHTTPBridge:
 
         url = self.config.base_url.rstrip("/") + path
         if query:
-            import urllib.parse
             qs = urllib.parse.urlencode(query)
             url = f"{url}?{qs}"
 
+        # Token-exfil guard: only attach the Splice session bearer when the
+        # destination is a splice.com-owned HTTPS host. A poisoned base_url
+        # (custom config/env) otherwise leaks the rotating session token to an
+        # attacker-controlled endpoint. Explicit opt-in via
+        # allow_unverified_endpoints / SPLICE_ALLOW_UNVERIFIED_ENDPOINTS=1.
+        if not _is_trusted_splice_host(url) and not self.config.allow_unverified_endpoints:
+            raise SpliceHTTPError(
+                code="UNTRUSTED_ENDPOINT",
+                message=(
+                    f"Refusing to send the Splice session token to non-Splice host "
+                    f"'{self.config.base_url}'. Set allow_unverified_endpoints in "
+                    f"~/.livepilot/splice.json (or SPLICE_ALLOW_UNVERIFIED_ENDPOINTS=1) "
+                    f"to override."
+                ),
+                endpoint=path,
+            )
+
         data_bytes = None
         headers = {
             "Authorization": f"Bearer {token}",

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