livepilot 1.22.1 → 1.23.1

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## v1.23.1 — 2026-04-25
+
+### Fixed
+- `extension_atlas_search` multi-word queries returned 0 hits because the search did literal-substring matching. `"sophie ponyboy"` failed to match `"SOPHIE — Ponyboy kick"` because of the em-dash separator. Now: query is tokenized on whitespace, each token must match somewhere (AND semantics), per-token scores sum for ranking. Single-token queries collapse to the original behavior — fully backwards-compatible.
+
+### Tests
+- 3 new tests covering multi-token AND, em-dash separator handling, per-token score aggregation.
+
+## v1.23.0 — 2026-04-25
+
+### Added
+- **User-local atlas overlay mechanism** for extending the atlas with namespaced YAML content from `~/.livepilot/atlas-overlays/<namespace>/` (custom hardware libraries, signature chains, technique recipes). Survives npm updates. Generalizes the v1.22.0 user-scan pattern from "atlas data" to "any user-local namespace."
+- 3 new MCP tools (430 → 433):
+  - `extension_atlas_search(query, namespace?, entity_type?, limit?)` — weighted substring search across overlay entries
+  - `extension_atlas_get(namespace, entity_id)` — fetch a single overlay entry with full body (including `requires_firmware` if present)
+  - `extension_atlas_list(namespace?)` — enumerate namespaces + entity_type counts
+- New file: `mcp_server/atlas/overlays.py` — `OverlayEntry` dataclass, `OverlayIndex` class, `load_overlays()`, lazy path resolver, module-level singleton.
+- New doc: `docs/EXTENSION_API.md` — public API contract for extension authors.
+
+### Behavior
+- Atlas overlays load at server boot from `~/.livepilot/atlas-overlays/`. Non-fatal — server continues if missing or malformed.
+- Loader uses `yaml.safe_load` only (rejects Python tags). Per-file parse failures log a WARN and skip the file; per-entry validation failures log a WARN and skip the entry; duplicate `(namespace, entity_type, entity_id)` last-loaded wins with a WARN.
+- For `entity_type: signature_chain`, `tags` and `artists` are required (search ranker depends on them). Other entity types treat these as optional.
+- `entity_id` and `entity_type` are str-coerced to defend against YAML scalar values like `entity_id: 42`.
+
+### Notes for extension authors
+- The contract (`OverlayEntry` field names, `extension_atlas_*` tool API) is stable from v1.23.0 forward.
+- Tool-name collisions: FastMCP enforces first-registered-wins. Bundled tools always beat extensions.
+- Phase 2 (user-local Python extensions via `register(mcp)`) lands in a future minor version.
+
+Spec: `docs/superpowers/specs/2026-04-25-user-local-extensions-design.md` (gitignored, design-time artifact)
+Plan: `docs/superpowers/plans/2026-04-25-phase-1a-atlas-overlays-plan.md` (gitignored, implementation tracker)
+
 ## 1.22.1 — Bundled enrichment coverage gate (April 25 2026)
 
 Closes the one item carried from v1.22.0's atlas-separation work: a

package/README.md

@@ -17,7 +17,7 @@
 
 <p align="center">
   An agentic production system for Ableton Live 12.<br>
-  430 tools. 53 domains. Device atlas. Plan-aware Splice integration. Auto-composition. Spectral perception. Technique memory. Drum-rack pad builder. Live dead-device detection.
+  433 tools. 53 domains. Device atlas. Plan-aware Splice integration. Auto-composition. Spectral perception. Technique memory. Drum-rack pad builder. Live dead-device detection.
 </p>
 
 <br>
@@ -82,7 +82,7 @@ Most MCP servers are tool collections — they execute commands. LivePilot is an
 │         └─────────────────┼──────────────────┘                       │
 │                           ▼                                          │
 │                  ┌─────────────────┐                                  │
-│                  │   430 MCP Tools  │                                  │
+│                  │   433 MCP Tools  │                                  │
 │                  │   53 domains     │                                  │
 │                  └────────┬────────┘                                  │
 │                           │                                          │
@@ -123,7 +123,7 @@ Most MCP servers are tool collections — they execute commands. LivePilot is an
 
 ## The Intelligence Layer
 
-12 engines sit on top of the 430 tools. They give the AI musical judgment, not just musical execution.
+12 engines sit on top of the 433 tools. They give the AI musical judgment, not just musical execution.
 
 ### SongBrain — What the Song Is
 
@@ -175,7 +175,7 @@ Every engine follows: **measure before → act → measure after → compare**.
 
 ## Tools
 
-430 tools across 53 domains. Highlights below — [full catalog here](docs/manual/tool-catalog.md).
+433 tools across 53 domains. Highlights below — [full catalog here](docs/manual/tool-catalog.md).
 
 <br>
 
@@ -230,7 +230,7 @@ WARP ─────────── get / add / move / remove markers
 
 <br>
 
-### Device Atlas — 10 tools
+### Device Atlas — 13 tools
 
 The atlas is an in-memory indexed database of Ableton's entire device library.
 
@@ -254,8 +254,13 @@ atlas_techniques_for_device    Reverse-lookup: what techniques reference this de
 atlas_pack_info                Inspect a single Ableton pack — devices + enrichment coverage
 scan_full_library              Scan what's actually installed on this machine
 reload_atlas                   Hot-reload the atlas after adding enrichments
+extension_atlas_search         [v1.23.0+] Search user-local atlas overlays
+extension_atlas_get            [v1.23.0+] Fetch a single overlay entry by namespace
+extension_atlas_list           [v1.23.0+] Enumerate overlay namespaces + entity_type counts
 ```
 
+**v1.23.0 — User-local extensions:** Drop YAML files at `~/.livepilot/atlas-overlays/<namespace>/` to extend the atlas with custom hardware libraries, signature chains, or technique recipes — survives npm updates. See [`docs/EXTENSION_API.md`](docs/EXTENSION_API.md).
+
 <br>
 
 ### Sample Engine — 23 tools
@@ -391,7 +396,7 @@ The V2 intelligence layer. These tools analyze, diagnose, plan, evaluate, and le
 | Creative Constraints | 5 | constraint activation, reference-inspired variants |
 | Preview Studio | 5 | variant creation, preview rendering, comparison, commit |
 
-> **[View all 430 tools →](docs/manual/tool-catalog.md)**
+> **[View all 433 tools →](docs/manual/tool-catalog.md)**
 
 <br>
 
@@ -618,7 +623,7 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for architecture details, code guidelines
 
 | Document | What's inside |
 |----------|---------------|
-| [Manual](docs/manual/index.md) | Complete reference: architecture, all 430 tools, workflows |
+| [Manual](docs/manual/index.md) | Complete reference: architecture, all 433 tools, workflows |
 | [Intelligence Layer](docs/manual/intelligence.md) | How the 12 engines connect — conductor, moves, preview, evaluation |
 | [Device Atlas](docs/manual/device-atlas.md) | 5264 devices indexed — search, suggest, chain building |
 | [Samples & Slicing](docs/manual/samples.md) | 3-source search, fitness critics, slice workflows |

package/m4l_device/livepilot_bridge.js

@@ -34,7 +34,7 @@ outlets = 2; // 0: to udpsend (responses), 1: to buffer~/status
 // Single source of truth for the bridge version — bumped alongside the
 // rest of the release manifest. Surfaced in the UI via messnamed("livepilot_version", ...)
 // so the frozen .amxd visibly reports which build it was last exported from.
-var VERSION = "1.21.3";
+var VERSION = "1.23.0";
 
 // ── State ──────────────────────────────────────────────────────────────────
 

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.22.1"
+__version__ = "1.23.1"

package/mcp_server/atlas/__init__.py

@@ -596,3 +596,9 @@ def invalidate_atlas() -> None:
 def _load_atlas() -> AtlasManager:
     """Legacy shim — kept so atlas/tools.py still works. Prefer get_atlas()."""
     return get_atlas()
+
+
+# v1.23.0: re-export overlay accessor so callers can do
+# `from mcp_server.atlas import get_overlay_index` mirroring the existing
+# `from mcp_server.atlas import get_atlas` ergonomic.
+from .overlays import get_overlay_index, load_overlays  # noqa: E402, F401

package/mcp_server/atlas/overlays.py

@@ -0,0 +1,282 @@
+# mcp_server/atlas/overlays.py
+"""User-local atlas overlay loader (v1.23.0).
+
+Generalizes the v1.22.0 BUNDLED_ATLAS_PATH / USER_ATLAS_PATH pattern to
+support arbitrary user-local namespaces of YAML overlay entries
+(machines, signature chains, aesthetic lineages, techniques) under
+~/.livepilot/atlas-overlays/<namespace>/.
+
+Per spec: docs/superpowers/specs/2026-04-25-user-local-extensions-design.md
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class OverlayEntry:
+    """A single overlay entity loaded from a YAML file under a namespace.
+
+    Field names mirror the spec §5.1. `entity_id` (not `id`) avoids
+    shadowing the Python `id()` builtin and matches the
+    `OverlayIndex.get(namespace, entity_id)` accessor signature.
+
+    For entity_type='signature_chain', `tags` and `artists` are required
+    (the search ranker hits them). The loader enforces this — see
+    `_validate_entry` (added in a later task).
+    """
+    namespace: str
+    entity_type: str
+    entity_id: str
+    name: str
+    description: str
+    tags: list[str] = field(default_factory=list)
+    artists: list[str] = field(default_factory=list)
+    requires_box: Optional[str] = None
+    body: dict = field(default_factory=dict)
+
+
+class OverlayIndex:
+    """In-memory index of overlay entries, partitioned by (namespace, entity_type, entity_id).
+
+    Mutated in place by load_overlays() (added in a later task). Tools call
+    get_overlay_index() at request time to read the current state — never
+    capture a reference at import time.
+    """
+
+    def __init__(self) -> None:
+        self._entries: dict[tuple[str, str, str], OverlayEntry] = {}
+
+    def add(self, entry: OverlayEntry) -> Optional[OverlayEntry]:
+        """Insert or replace. Returns the previous entry on collision (or None
+        on a fresh insert) so callers can log a duplicate-id warning per spec §7."""
+        key = (entry.namespace, entry.entity_type, entry.entity_id)
+        previous = self._entries.get(key)
+        self._entries[key] = entry
+        return previous
+
+    def get(self, namespace: str, entity_id: str) -> Optional[OverlayEntry]:
+        """Lookup by (namespace, entity_id), ignoring entity_type.
+
+        If two entries share the same (namespace, entity_id) across different
+        entity_types, returns whichever the dict iterator yields first
+        (insertion order in CPython 3.7+). The loader (Tasks 7+8) is responsible
+        for preventing such collisions via dup-id warnings.
+        """
+        for (ns, _et, eid), entry in self._entries.items():
+            if ns == namespace and eid == entity_id:
+                return entry
+        return None
+
+    def list_namespaces(self) -> list[str]:
+        return sorted({ns for (ns, _, _) in self._entries.keys()})
+
+    def list_entity_types(self, namespace: str) -> list[str]:
+        return sorted({et for (ns, et, _) in self._entries.keys() if ns == namespace})
+
+    def clear(self) -> None:
+        """Reset for idempotency (used by load_overlays in a later task)."""
+        self._entries.clear()
+
+    def all_entries(self) -> list[OverlayEntry]:
+        return list(self._entries.values())
+
+    def search(self, query: str, namespace: Optional[str] = None,
+               entity_type: Optional[str] = None,
+               limit: int = 10) -> list[OverlayEntry]:
+        """Weighted substring search with whitespace-tokenized AND semantics.
+
+        The query is split on whitespace into tokens. Each token is scored
+        against each entry independently:
+          +1000 if token == entity_id (case-insensitive exact match)
+          +100  per substring hit in name
+          +50   per substring hit in tag or artist
+          +10   per substring hit in description
+
+        An entry matches only if EVERY token scores > 0 somewhere (AND
+        semantics — prevents 'sophie ponyboy' from matching unrelated
+        entries that contain only one of the two words). The entry's
+        final score is the sum across all tokens.
+
+        Sorts by descending score, then by entity_id for stable ties.
+        Filters by namespace and/or entity_type if provided.
+        Empty query returns empty list.
+        """
+        q = (query or "").strip().lower()
+        if not q:
+            return []
+        tokens = q.split()
+        if not tokens:
+            return []
+
+        scored: list[tuple[int, str, OverlayEntry]] = []
+        for entry in self._entries.values():
+            if namespace is not None and entry.namespace != namespace:
+                continue
+            if entity_type is not None and entry.entity_type != entity_type:
+                continue
+
+            name_lower = entry.name.lower()
+            entity_id_lower = entry.entity_id.lower()
+            description_lower = entry.description.lower()
+            tags_lower = [str(t).lower() for t in entry.tags]
+            artists_lower = [str(a).lower() for a in entry.artists]
+
+            token_scores = []
+            for tok in tokens:
+                s = 0
+                if entity_id_lower == tok:
+                    s += 1000
+                if tok in name_lower:
+                    s += 100
+                for tag in tags_lower:
+                    if tok in tag:
+                        s += 50
+                for artist in artists_lower:
+                    if tok in artist:
+                        s += 50
+                if tok in description_lower:
+                    s += 10
+                token_scores.append(s)
+
+            # AND semantics — every token must match somewhere
+            if all(s > 0 for s in token_scores):
+                scored.append((sum(token_scores), entry.entity_id, entry))
+
+        scored.sort(key=lambda triple: (-triple[0], triple[1]))
+        return [entry for (_, _, entry) in scored[:max(0, limit)]]
+
+    def stats(self) -> dict:
+        """Counts per namespace per entity_type (used by extension_atlas_list in Task 12)."""
+        counts: dict[str, dict[str, int]] = {}
+        for (ns, et, _eid) in self._entries.keys():
+            counts.setdefault(ns, {}).setdefault(et, 0)
+            counts[ns][et] += 1
+        return counts
+
+
+def _resolve_overlay_root() -> Path:
+    """Lazy resolver mirroring v1.22.0 _resolve_atlas_path() pattern.
+    Tests monkeypatch Path.home() and expect this to re-evaluate."""
+    return Path.home() / ".livepilot" / "atlas-overlays"
+
+
+def _validate_entry(entry: dict, source_path: Path,
+                    log: logging.Logger) -> bool:
+    """True if entry has required fields. Log + return False otherwise.
+
+    Per spec §5.1:
+      - All entries: entity_id + entity_type required
+      - entity_type=signature_chain: also tags + artists required
+    """
+    eid = entry.get("entity_id")
+    etype = entry.get("entity_type")
+    if not eid:
+        log.warning(f"overlays: skipped entry in {source_path}: missing 'entity_id'")
+        return False
+    if not etype:
+        log.warning(f"overlays: skipped {eid} in {source_path}: missing 'entity_type'")
+        return False
+    if etype == "signature_chain":
+        if not entry.get("tags"):
+            log.warning(f"overlays: skipped {eid} in {source_path}: signature_chain requires 'tags'")
+            return False
+        if not entry.get("artists"):
+            log.warning(f"overlays: skipped {eid} in {source_path}: signature_chain requires 'artists'")
+            return False
+    return True
+
+
+def _entry_from_dict(d: dict, namespace: str) -> OverlayEntry:
+    """Build an OverlayEntry from a validated YAML dict.
+    The full original dict is preserved as `body` so callers can read
+    arbitrary extra fields (architecture, requires_machines, sources, etc.).
+
+    Coerces entity_id and entity_type to str() defensively — guards against
+    YAMLs that use non-string scalar values (e.g., `entity_id: 42`) which
+    would otherwise break downstream search() (.lower() on int).
+    """
+    return OverlayEntry(
+        namespace=namespace,
+        entity_type=str(d["entity_type"]),
+        entity_id=str(d["entity_id"]),
+        name=d.get("name", ""),
+        description=d.get("description", ""),
+        tags=list(d.get("tags") or []),
+        artists=list(d.get("artists") or []),
+        requires_box=d.get("requires_box"),
+        body=d,
+    )
+
+
+def load_overlays(root: Optional[Path] = None,
+                  log: Optional[logging.Logger] = None) -> "OverlayIndex":
+    """Scan root for namespace subdirs; load YAMLs; mutate the singleton; return it.
+
+    Per spec §5.1:
+      - Each immediate subdirectory of root is a namespace.
+      - Within each namespace, *.yaml/*.yml files are loaded recursively.
+      - File may contain a single dict OR a list of dicts.
+      - yaml.safe_load ONLY (rejects Python tags).
+      - Idempotent: clears the singleton first.
+    """
+    log = log or logger
+    if root is None:
+        root = _resolve_overlay_root()
+
+    idx = get_overlay_index()
+    idx.clear()
+
+    if not root.exists():
+        return idx
+
+    for ns_dir in sorted(root.iterdir()):
+        if not ns_dir.is_dir():
+            continue
+        namespace = ns_dir.name
+        for yaml_path in sorted(list(ns_dir.rglob("*.yaml")) +
+                                list(ns_dir.rglob("*.yml"))):
+            try:
+                with yaml_path.open("r") as f:
+                    parsed = yaml.safe_load(f)
+            except yaml.YAMLError as e:
+                log.warning(f"overlays: skipped {yaml_path}: {e}")
+                continue
+
+            if parsed is None:
+                continue
+            entries = parsed if isinstance(parsed, list) else [parsed]
+            for entry_dict in entries:
+                if not isinstance(entry_dict, dict):
+                    log.warning(f"overlays: skipped non-dict entry in {yaml_path}")
+                    continue
+                if not _validate_entry(entry_dict, yaml_path, log):
+                    continue
+                new_entry = _entry_from_dict(entry_dict, namespace)
+                previous = idx.add(new_entry)
+                if previous is not None:
+                    log.warning(
+                        f"overlays: duplicate ({new_entry.namespace}, "
+                        f"{new_entry.entity_type}, {new_entry.entity_id}) "
+                        f"in {yaml_path} — last-loaded wins"
+                    )
+    return idx
+
+
+# Module-level singleton — initialized empty at import. Per spec §5.1, §6.1.
+# load_overlays() mutates this in place. Tools call get_overlay_index() at
+# request time so they always see current state (never capture a reference).
+_overlay_index: "OverlayIndex" = OverlayIndex()
+
+
+def get_overlay_index() -> "OverlayIndex":
+    """Accessor for the live overlay singleton. Always returns the same
+    instance — load_overlays() mutates it in place rather than replacing."""
+    return _overlay_index

package/mcp_server/atlas/tools.py

@@ -588,3 +588,101 @@ def reload_atlas(ctx: Context) -> dict:
         "reloaded": True,
         "device_count": atlas.device_count if atlas else 0,
     }
+
+
+# ─────────────────────────────────────────────────────────────────────────
+# v1.23.0: User-local atlas overlays (extension_atlas_*)
+#
+# These tools surface the OverlayIndex populated by load_overlays() at
+# server boot from ~/.livepilot/atlas-overlays/<namespace>/. Independent
+# of the existing atlas_* tools, which are tightly coupled to the device
+# schema (URIs, packs, categories). Per spec §5.3.
+# ─────────────────────────────────────────────────────────────────────────
+
+
+def _serialize_overlay_entry(entry) -> dict:
+    """Serialize an OverlayEntry to a JSON-safe dict for MCP tool returns."""
+    return {
+        "namespace": entry.namespace,
+        "entity_type": entry.entity_type,
+        "entity_id": entry.entity_id,
+        "name": entry.name,
+        "description": entry.description,
+        "tags": entry.tags,
+        "artists": entry.artists,
+        "requires_box": entry.requires_box,
+        "body": entry.body,
+    }
+
+
+@mcp.tool()
+def extension_atlas_search(ctx: Context, query: str,
+                           namespace: str = "",
+                           entity_type: str = "",
+                           limit: int = 10) -> dict:
+    """Search user-local atlas overlays under ~/.livepilot/atlas-overlays/.
+
+    Use this for content from extension namespaces (e.g., 'elektron', 'prophet') —
+    NOT for the main Ableton device atlas (use atlas_search for that).
+
+    query:       case-insensitive substring; matches against entity_id (highest weight),
+                 name, tags/artists, description (lowest weight).
+    namespace:   restrict to one namespace (e.g., 'elektron'); empty = search all.
+    entity_type: restrict to one entity_type (e.g., 'signature_chain'); empty = all.
+    limit:       maximum results to return.
+    """
+    from .overlays import get_overlay_index
+    idx = get_overlay_index()
+    ns = namespace or None
+    et = entity_type or None
+    matches = idx.search(query, namespace=ns, entity_type=et, limit=limit)
+    return {
+        "query": query,
+        "namespace": namespace or None,
+        "entity_type": entity_type or None,
+        "count": len(matches),
+        "results": [_serialize_overlay_entry(e) for e in matches],
+    }
+
+
+@mcp.tool()
+def extension_atlas_get(ctx: Context, namespace: str, entity_id: str) -> dict:
+    """Fetch a single overlay entry by namespace + entity_id.
+
+    Returns the full entry including the original YAML body so callers can read
+    arbitrary extension-specific fields (architecture, requires_machines,
+    requires_firmware, sources, etc.).
+
+    If the entry has a `requires_firmware` field, surface it to the user before
+    recommending the chain (per spec §7) — e.g., "this needs Monomachine OS 1.32+".
+    """
+    from .overlays import get_overlay_index
+    idx = get_overlay_index()
+    entry = idx.get(namespace, entity_id)
+    if entry is None:
+        return {
+            "error": f"entity '{entity_id}' not found in namespace '{namespace}'",
+            "suggestion": "Use extension_atlas_search to find available entries, "
+                          "or extension_atlas_list to see installed namespaces."
+        }
+    return _serialize_overlay_entry(entry)
+
+
+@mcp.tool()
+def extension_atlas_list(ctx: Context, namespace: str = "") -> dict:
+    """Enumerate user-local overlay namespaces and their entity_type counts.
+
+    With no namespace: returns full list of namespaces and per-type counts.
+    With a namespace: returns just the entity_types present in that namespace.
+    """
+    from .overlays import get_overlay_index
+    idx = get_overlay_index()
+    if namespace:
+        return {
+            "namespace": namespace,
+            "entity_types": idx.list_entity_types(namespace),
+        }
+    return {
+        "namespaces": idx.list_namespaces(),
+        "counts": idx.stats(),
+    }

package/mcp_server/server.py

@@ -497,6 +497,35 @@ _assert_tool_registry_accessible()
 _patch_tool_schemas()
 
 
+# ─────────────────────────────────────────────────────────────────────────
+# v1.23.0: User-local atlas overlay boot hook.
+#
+# Loads YAMLs from ~/.livepilot/atlas-overlays/<namespace>/ into the
+# module-level OverlayIndex singleton. The 3 extension_atlas_* tools
+# registered above resolve the singleton at REQUEST time (via the
+# get_overlay_index() accessor), so this load can happen after their
+# registration without ordering issues.
+#
+# Failures are logged but never abort boot — server starts even if the
+# user has no overlays installed or has malformed YAMLs.
+# Spec: docs/superpowers/specs/2026-04-25-user-local-extensions-design.md §6.1
+# ─────────────────────────────────────────────────────────────────────────
+try:
+    from .atlas.overlays import load_overlays
+    _overlay_idx_at_boot = load_overlays()
+    _overlay_count = len(_overlay_idx_at_boot.all_entries())
+    if _overlay_count:
+        logger.info(
+            f"User-local overlays loaded: {_overlay_count} entries across "
+            f"namespaces {_overlay_idx_at_boot.list_namespaces()}"
+        )
+    else:
+        logger.debug("User-local overlays: none installed at "
+                     "~/.livepilot/atlas-overlays/")
+except Exception as e:
+    logger.warning(f"User-local overlay load failed (non-fatal, server continues): {e}")
+
+
 def main():
     """Run the MCP server over stdio."""
     mcp.run(transport="stdio")

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.22.1",
+  "version": "1.23.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 430 tools, 53 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
+  "description": "Agentic production system for Ableton Live 12 — 433 tools, 53 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.22.1"
+__version__ = "1.23.1"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "430-tool agentic MCP production system for Ableton Live 12 — 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
+  "description": "433-tool agentic MCP production system for Ableton Live 12 — 53 domains, 44 semantic moves, device atlas (5264 devices), Splice intelligence (gRPC + GraphQL), 9-band spectral perception auto-loaded, Creative Director skill, technique memory, 12 creative engines",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.22.1",
+  "version": "1.23.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.22.1",
+      "version": "1.23.1",
       "transport": {
         "type": "stdio"
       }