livepilot 1.26.2 → 1.27.1

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/analyzer.py

@@ -171,6 +171,18 @@ async def _try_native_replace_sample(
     return resp
 
 
+def _normalize_native_fallback_reason(skip_reason: Optional[str]) -> Optional[str]:
+    if not skip_reason:
+        return None
+    if skip_reason.startswith("gate_closed:"):
+        return "live_version_below_12_4"
+    return skip_reason
+
+
+def _native_dispatch_was_attempted(skip_reason: Optional[str]) -> bool:
+    return bool(skip_reason) and not skip_reason.startswith("gate_closed:")
+
+
 @mcp.tool()
 async def reconnect_bridge(ctx: Context) -> dict:
     """Attempt to reconnect the M4L UDP bridge (port 9880).
@@ -627,6 +639,9 @@ async def replace_simpler_sample(
         result = dict(native)
         result.update(hygiene)
         result["method"] = "native_12_4"  # preserved in case hygiene ever adds its own key
+        result["native_attempted"] = True
+        result["bridge_attempted"] = False
+        result["fallback_reason"] = None
         return result
 
     # Pre-12.4 fallback: M4L bridge path (unchanged behavior).
@@ -636,11 +651,17 @@ async def replace_simpler_sample(
     )
 
     if "error" in result:
+        result["native_attempted"] = _native_dispatch_was_attempted(skip_reason)
+        result["bridge_attempted"] = True
+        result["fallback_reason"] = _normalize_native_fallback_reason(skip_reason)
         return result
     if not result.get("sample_loaded"):
         return {
             "error": "Sample may not have loaded. Ensure the Simpler already "
-            "has a sample loaded — replace_sample silently fails on empty Simplers."
+            "has a sample loaded — replace_sample silently fails on empty Simplers.",
+            "native_attempted": _native_dispatch_was_attempted(skip_reason),
+            "bridge_attempted": True,
+            "fallback_reason": _normalize_native_fallback_reason(skip_reason),
         }
 
     hygiene = await _simpler_post_load_hygiene(
@@ -652,6 +673,9 @@ async def replace_simpler_sample(
 
     result.update(hygiene)
     result["method"] = "bridge_m4l"
+    result["native_attempted"] = _native_dispatch_was_attempted(skip_reason)
+    result["bridge_attempted"] = True
+    result["fallback_reason"] = _normalize_native_fallback_reason(skip_reason)
     if skip_reason:
         result["native_skip_reason"] = skip_reason
     return result
@@ -692,7 +716,10 @@ async def load_sample_to_simpler(
     # Live 12.4+: create an empty Simpler via insert_device, then use the
     # native replace_sample path. Skips the dummy-sample bootstrap entirely.
     caps = _live_caps(ctx)
+    native_attempted = False
+    fallback_reason = "live_version_below_12_4"
     if caps.has_replace_sample_native:
+        fallback_reason = "native_insert_device_unavailable"
         try:
             ins = ableton.send_command("insert_device", {
                 "track_index": track_index,
@@ -701,6 +728,7 @@ async def load_sample_to_simpler(
         except Exception:
             ins = None
         if isinstance(ins, dict) and "error" not in ins:
+            native_attempted = True
             actual_device_index = ins.get("device_index", device_index)
             native = await _try_native_replace_sample(
                 ctx, track_index, actual_device_index, file_path
@@ -717,7 +745,13 @@ async def load_sample_to_simpler(
                 result["method"] = "native_12_4"
                 result["device_index"] = actual_device_index
                 result["track_index"] = track_index
+                result["native_attempted"] = True
+                result["bridge_attempted"] = False
+                result["fallback_reason"] = None
                 return result
+            fallback_reason = _normalize_native_fallback_reason(
+                ctx.lifespan_context.get("_native_replace_skip_reason")
+            ) or "native_replace_failed"
         # Fall through to the legacy bootstrap path below on any failure.
 
     # Step 1: Load a sample from the browser to create Simpler with content
@@ -774,6 +808,9 @@ async def load_sample_to_simpler(
     result["method"] = "bootstrap_and_replace"
     result["device_index"] = actual_device_index  # additive — for step-result binding
     result["track_index"] = track_index
+    result["native_attempted"] = native_attempted
+    result["bridge_attempted"] = True
+    result["fallback_reason"] = fallback_reason
     return result
 
 

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)