livepilot 1.23.2 → 1.23.4

package/mcp_server/tools/perception.py

@@ -93,7 +93,11 @@ def analyze_loudness(
     file_path: str,
     detail: str = "summary",
 ) -> dict[str, Any]:
-    """Analyze the integrated loudness of an audio file (offline — no Ableton needed).
+    """Analyze the integrated loudness of an audio file (OFFLINE — needs a rendered file).
+
+    ⚠ This tool reads a file on disk. It does NOT connect to Ableton.
+    For live session monitoring while a track is playing, use
+    analyze_loudness_live() instead — no file needed.
 
     Computes integrated LUFS (EBU R128), true peak, RMS, crest factor,
     loudness range (LRA), and streaming platform compliance.

package/mcp_server/tools/tracks.py

@@ -163,21 +163,52 @@ def _find_name_collisions(ctx: Context, name: str) -> list[int]:
     return matches
 
 
+def _resolve_color_alias(
+    color: Optional[int],
+    color_index: Optional[int],
+) -> Optional[int]:
+    """BUG-2026-04-26#3: accept both `color` and `color_index` keywords.
+
+    The track-creation tools used `color` while `set_track_color` used
+    `color_index`. Callers writing parallel tool batches (create + paint
+    in one shot) consistently picked the wrong name and lost a whole
+    parallel batch to the validation error. This helper accepts either,
+    rejects the conflict case, and returns the resolved value.
+    """
+    if color is not None and color_index is not None:
+        if color != color_index:
+            raise ValueError(
+                "Pass either 'color' or 'color_index', not both with "
+                f"different values (got color={color}, color_index={color_index})"
+            )
+        return color
+    if color is not None:
+        return color
+    return color_index
+
+
 @mcp.tool()
 def create_midi_track(
     ctx: Context,
     index: int = -1,
     name: Optional[str] = None,
     color: Optional[int] = None,
+    color_index: Optional[int] = None,
 ) -> dict:
     """Create a new MIDI track. index=-1 appends at end.
 
+    `color` and `color_index` are accepted interchangeably (BUG-2026-04-26#3).
+    Both reference Ableton's 0-69 color palette. Pass either; passing
+    both with different values is rejected.
+
     Response (v1.20.2+): when `name` is provided, the response carries
     a ``name_collision`` bool and ``existing_tracks_with_same_name``
     list[int]. Downstream role-based resolvers (find_tracks_by_role)
     match duplicate names and apply mix changes twice — check the
     warning before proceeding with mix moves on the new track's role.
     """
+    color = _resolve_color_alias(color, color_index)
+
     collisions: list[int] = []
     if name is not None and name.strip():
         collisions = _find_name_collisions(ctx, name)
@@ -205,12 +236,18 @@ def create_audio_track(
     index: int = -1,
     name: Optional[str] = None,
     color: Optional[int] = None,
+    color_index: Optional[int] = None,
 ) -> dict:
     """Create a new audio track. index=-1 appends at end.
 
+    `color` and `color_index` are accepted interchangeably (BUG-2026-04-26#3).
+    See create_midi_track for full semantics.
+
     Response (v1.20.2+): ``name_collision`` + ``existing_tracks_with_same_name``
     same as create_midi_track — see BUG #5 rationale there.
     """
+    color = _resolve_color_alias(color, color_index)
+
     collisions: list[int] = []
     if name is not None and name.strip():
         collisions = _find_name_collisions(ctx, name)
@@ -309,12 +346,12 @@ def set_track_solo(ctx: Context, track_index: int, solo: bool) -> dict:
 
 
 @mcp.tool()
-def set_track_arm(ctx: Context, track_index: int, armed: bool) -> dict:
+def set_track_arm(ctx: Context, track_index: int, arm: bool) -> dict:
     """Arm or disarm a track for recording."""
     _validate_track_index(track_index)
     return _get_ableton(ctx).send_command("set_track_arm", {
         "track_index": track_index,
-        "arm": armed,
+        "arm": arm,
     })
 
 

package/mcp_server/user_corpus/__init__.py

@@ -0,0 +1,48 @@
+"""User-corpus builder — scan your own .als / .adg / .amxd / plugin presets / samples
+into queryable atlas overlays.
+
+See docs/USER_CORPUS_GUIDE.md for the full architecture + user guide.
+
+Public API:
+    from mcp_server.user_corpus import (
+        Scanner, register_scanner, get_scanner, list_scanners,
+        Manifest, Source, load_manifest, save_manifest,
+        run_scan, ScanResult,
+    )
+"""
+from __future__ import annotations
+
+from .scanner import Scanner, register_scanner, get_scanner, list_scanners
+from .manifest import (
+    Manifest,
+    Source,
+    load_manifest,
+    save_manifest,
+    init_default_manifest,
+    DEFAULT_MANIFEST_PATH,
+    DEFAULT_OUTPUT_ROOT,
+)
+from .runner import run_scan, ScanResult, SourceScanResult
+
+# Eager-import the built-in scanners so their @register_scanner decorators fire.
+from .scanners import als as _als  # noqa: F401
+from .scanners import adg as _adg  # noqa: F401
+from .scanners import amxd as _amxd  # noqa: F401
+from .scanners import plugin_preset as _pp  # noqa: F401
+
+__all__ = [
+    "Scanner",
+    "register_scanner",
+    "get_scanner",
+    "list_scanners",
+    "Manifest",
+    "Source",
+    "load_manifest",
+    "save_manifest",
+    "init_default_manifest",
+    "DEFAULT_MANIFEST_PATH",
+    "DEFAULT_OUTPUT_ROOT",
+    "run_scan",
+    "ScanResult",
+    "SourceScanResult",
+]

package/mcp_server/user_corpus/manifest.py

@@ -0,0 +1,142 @@
+"""Manifest — declarative source registry for user corpus scans.
+
+Schema lives in the YAML; this module is just (de)serialization + dataclasses.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+
+# ─── Default paths ───────────────────────────────────────────────────────────
+
+DEFAULT_OUTPUT_ROOT = Path.home() / ".livepilot" / "atlas-overlays" / "user"
+DEFAULT_MANIFEST_PATH = DEFAULT_OUTPUT_ROOT / "manifest.yaml"
+
+CURRENT_SCHEMA_VERSION = 1
+
+
+# ─── Data classes ────────────────────────────────────────────────────────────
+
+
+@dataclass
+class Source:
+    """One declared scan source."""
+    id: str
+    type: str                           # scanner type_id
+    path: str                           # filesystem path (may contain ~)
+    recursive: bool = True
+    exclude_globs: list[str] = field(default_factory=list)
+    last_scanned: str | None = None     # ISO 8601 UTC, set by the runner
+    file_count: int | None = None       # set by the runner after scan
+    options: dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def resolved_path(self) -> Path:
+        return Path(os.path.expanduser(self.path)).resolve()
+
+    def mark_scanned(self, file_count: int) -> None:
+        self.last_scanned = datetime.now(timezone.utc).isoformat(timespec="seconds")
+        self.file_count = file_count
+
+
+@dataclass
+class Manifest:
+    """Top-level manifest — all scan sources + global options."""
+    schema_version: int = CURRENT_SCHEMA_VERSION
+    sources: list[Source] = field(default_factory=list)
+    output: dict[str, Any] = field(default_factory=lambda: {
+        "root": str(DEFAULT_OUTPUT_ROOT),
+        "schema_version": CURRENT_SCHEMA_VERSION,
+    })
+    options: dict[str, Any] = field(default_factory=lambda: {
+        "parallel_workers": 4,
+        "skip_unchanged": True,
+        "log_level": "info",
+        "on_error": "continue",
+    })
+    ai_annotation: dict[str, Any] = field(default_factory=lambda: {
+        "enabled": False,
+        "model": "sonnet",
+        "fields": [
+            "sonic_fingerprint",
+            "tags",
+            "reach_for",
+            "avoid",
+            "cross_references",
+        ],
+    })
+
+    @property
+    def output_root(self) -> Path:
+        return Path(os.path.expanduser(self.output.get("root", str(DEFAULT_OUTPUT_ROOT))))
+
+    def find_source(self, source_id: str) -> Source | None:
+        for s in self.sources:
+            if s.id == source_id:
+                return s
+        return None
+
+    def add_source(self, source: Source) -> None:
+        if self.find_source(source.id):
+            raise ValueError(f"Source id '{source.id}' already exists; remove or rename first")
+        self.sources.append(source)
+
+    def remove_source(self, source_id: str) -> Source | None:
+        match = self.find_source(source_id)
+        if match:
+            self.sources.remove(match)
+        return match
+
+
+# ─── (De)serialization ───────────────────────────────────────────────────────
+
+
+def load_manifest(path: Path = DEFAULT_MANIFEST_PATH) -> Manifest:
+    """Load a manifest YAML. Returns a default Manifest if the file is missing."""
+    if not path.exists():
+        return Manifest()
+    raw = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    sources = [Source(**s) for s in (raw.get("sources") or [])]
+    return Manifest(
+        schema_version=raw.get("schema_version", CURRENT_SCHEMA_VERSION),
+        sources=sources,
+        output=raw.get("output") or Manifest().output,
+        options=raw.get("options") or Manifest().options,
+        ai_annotation=raw.get("ai_annotation") or Manifest().ai_annotation,
+    )
+
+
+def save_manifest(manifest: Manifest, path: Path = DEFAULT_MANIFEST_PATH) -> None:
+    """Persist a manifest as YAML. Creates parent dirs if needed."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "schema_version": manifest.schema_version,
+        "sources": [
+            {k: v for k, v in asdict(s).items() if v is not None and v != [] and v != {}}
+            for s in manifest.sources
+        ],
+        "output": manifest.output,
+        "options": manifest.options,
+        "ai_annotation": manifest.ai_annotation,
+    }
+    path.write_text(
+        yaml.dump(data, sort_keys=False, default_flow_style=False, width=200, allow_unicode=True),
+        encoding="utf-8",
+    )
+
+
+def init_default_manifest(path: Path = DEFAULT_MANIFEST_PATH) -> Manifest:
+    """Create a fresh manifest at the default path, ensuring directory exists."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        return load_manifest(path)
+    m = Manifest()
+    save_manifest(m, path)
+    return m

package/mcp_server/user_corpus/plugin_engine/__init__.py

@@ -0,0 +1,39 @@
+"""Plugin Knowledge Engine — detects installed plugins, extracts identity from
+their bundles, finds + extracts manuals, and emits research / synthesis briefs
+for the agent to fulfill via WebSearch + sonnet subagents.
+
+See docs/PLUGIN_KNOWLEDGE_ENGINE.md for the full architecture.
+
+Public API:
+    from mcp_server.user_corpus.plugin_engine import (
+        detect_installed_plugins, discover_manuals_for_plugin,
+        extract_manual_text, build_research_targets,
+        build_synthesis_brief, default_plugin_dir,
+    )
+"""
+from __future__ import annotations
+
+from .detector import (
+    detect_installed_plugins,
+    default_plugin_dir,
+    DetectedPlugin,
+)
+from .manual import (
+    discover_manuals_for_plugin,
+    extract_manual_text,
+    ManualCandidate,
+    ManualExtraction,
+)
+from .research import build_research_targets, build_synthesis_brief
+
+__all__ = [
+    "detect_installed_plugins",
+    "default_plugin_dir",
+    "DetectedPlugin",
+    "discover_manuals_for_plugin",
+    "extract_manual_text",
+    "ManualCandidate",
+    "ManualExtraction",
+    "build_research_targets",
+    "build_synthesis_brief",
+]