livepilot 1.10.7 → 1.10.9

package/installer/install.js

@@ -1,6 +1,7 @@
 "use strict";
 
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 const { findAbletonPaths } = require("./paths");
 
@@ -10,6 +11,60 @@ const SOURCE_DIR = path.join(ROOT, "remote_script", "LivePilot");
 // Files / dirs to skip during copy
 const SKIP = new Set(["__pycache__", ".DS_Store"]);
 
+// How many previous backups to keep on disk before auto-pruning (the upgrade
+// path renames the old LivePilot dir to LivePilot.backup-<ts>/ so the user can
+// recover a manual edit).
+const BACKUP_RETENTION = 3;
+
+/**
+ * Typed installer error. Wrappers (e.g. the --setup wizard) can catch this
+ * and decide whether to continue with later steps (recoverable) or abort the
+ * whole wizard (non-recoverable). The previous version called process.exit(1)
+ * mid-function, which silently short-circuited the setup wizard — callers
+ * had try/catch expecting exceptions, so later steps (bootstrap, M4L install,
+ * diagnostics) were skipped without warning.
+ */
+class InstallerAbort extends Error {
+  constructor(message, { recoverable = false } = {}) {
+    super(message);
+    this.name = "InstallerAbort";
+    this.recoverable = recoverable;
+  }
+}
+
+/**
+ * Validate that a user-supplied install destination is somewhere safe.
+ * Refuses to write outside of the user's home directory unless it matches
+ * one of the known Ableton Remote Scripts paths. This closes the path-
+ * traversal hole from `LIVEPILOT_INSTALL_PATH=/etc ...`.
+ */
+function _assertSafeInstallPath(resolvedPath, candidates) {
+  const home = os.homedir();
+  const allowedPrefixes = [
+    home,
+    // Systemwide Ableton install paths that live outside $HOME on some platforms
+    "/Applications/Ableton",
+    "C:\\ProgramData\\Ableton",
+  ];
+  // The detected Ableton candidate paths are always considered safe
+  for (const c of candidates) {
+    if (path.resolve(c.path).startsWith(path.resolve(resolvedPath))) {
+      return;
+    }
+    if (path.resolve(resolvedPath).startsWith(path.resolve(c.path))) {
+      return;
+    }
+  }
+  const safe = allowedPrefixes.some((p) => resolvedPath.startsWith(path.resolve(p)));
+  if (!safe) {
+    throw new InstallerAbort(
+      `LIVEPILOT_INSTALL_PATH=${resolvedPath} is outside permitted directories. ` +
+      `Refusing to install. Allowed roots: ${allowedPrefixes.join(", ")}`,
+      { recoverable: false }
+    );
+  }
+}
+
 /**
  * Recursively copy a directory, skipping __pycache__ and .DS_Store.
  */
@@ -28,22 +83,51 @@ function copyDirSync(src, dest) {
   }
 }
 
+/**
+ * Prune old LivePilot.backup-<ts>/ dirs, keeping the most recent N.
+ */
+function _pruneBackups(parentDir) {
+  try {
+    const entries = fs.readdirSync(parentDir, { withFileTypes: true });
+    const backups = entries
+      .filter((e) => e.isDirectory() && /^LivePilot\.backup-\d+$/.test(e.name))
+      .map((e) => e.name)
+      .sort();  // lexicographic — timestamps are monotonic, so this is age order
+    while (backups.length > BACKUP_RETENTION) {
+      const old = backups.shift();
+      try {
+        fs.rmSync(path.join(parentDir, old), { recursive: true, force: true });
+      } catch {
+        // best effort — don't let cleanup failure break an install
+      }
+    }
+  } catch {
+    // best effort
+  }
+}
+
 /**
  * Install the LivePilot Remote Script into Ableton's Remote Scripts folder.
+ *
+ * Throws InstallerAbort on recoverable failures (auto-detect missing) or
+ * non-recoverable ones (path-traversal attempt). Never calls process.exit.
+ * This lets the setup wizard continue with later steps on a recoverable
+ * failure.
  */
 function install() {
   const candidates = findAbletonPaths();
 
   if (candidates.length === 0) {
-    console.log("Could not auto-detect an Ableton Live Remote Scripts directory.");
-    console.log("");
-    console.log("Manual install:");
-    console.log("  1. Open Ableton Live > Preferences > File/Folder");
-    console.log("  2. Find the User Remote Scripts folder path");
-    console.log("  3. Copy the 'remote_script/LivePilot' folder into that directory");
-    console.log("  4. Restart Ableton Live");
-    console.log("  5. In Preferences > Link/Tempo/MIDI, set a Control Surface to 'LivePilot'");
-    process.exit(1);
+    throw new InstallerAbort(
+      "Could not auto-detect an Ableton Live Remote Scripts directory.\n\n" +
+      "Manual install:\n" +
+      "  1. Open Ableton Live > Preferences > File/Folder\n" +
+      "  2. Find the User Remote Scripts folder path\n" +
+      "  3. Copy the 'remote_script/LivePilot' folder into that directory\n" +
+      "  4. Restart Ableton Live\n" +
+      "  5. In Preferences > Link/Tempo/MIDI, set a Control Surface to 'LivePilot'",
+      { recoverable: true }
+    );
   }
 
   // If multiple candidates exist, let the user choose via --install-path
@@ -51,7 +135,9 @@ function install() {
   let target;
   const explicitPath = process.env.LIVEPILOT_INSTALL_PATH;
   if (explicitPath) {
-    target = { path: explicitPath, description: "explicit (LIVEPILOT_INSTALL_PATH)" };
+    const resolved = path.resolve(explicitPath);
+    _assertSafeInstallPath(resolved, candidates);
+    target = { path: resolved, description: "explicit (LIVEPILOT_INSTALL_PATH)" };
   } else if (candidates.length > 1) {
     console.log("Multiple Ableton Remote Scripts directories detected:");
     candidates.forEach((c, i) => {
@@ -73,6 +159,25 @@ function install() {
   // Ensure target base exists
   fs.mkdirSync(targetBase, { recursive: true });
 
+  // Clear-then-copy upgrade path. Overlay-copying on top of an existing
+  // install leaves stale files when a module is removed/renamed upstream.
+  // Instead, rename the previous install to a timestamped backup, copy
+  // fresh, then prune old backups. The rename (not delete) preserves any
+  // local edits the user may have made.
+  if (fs.existsSync(destDir)) {
+    const ts = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+    const backup = path.join(targetBase, `LivePilot.backup-${ts}`);
+    try {
+      fs.renameSync(destDir, backup);
+      console.log("Existing install backed up to: %s", backup);
+    } catch (e) {
+      throw new InstallerAbort(
+        `Could not back up previous LivePilot install at ${destDir}: ${e.message}`,
+        { recoverable: false }
+      );
+    }
+  }
+
   console.log("Installing LivePilot Remote Script...");
   console.log("  Source: %s", SOURCE_DIR);
   console.log("  Target: %s", destDir);
@@ -80,6 +185,7 @@ function install() {
   console.log("");
 
   copyDirSync(SOURCE_DIR, destDir);
+  _pruneBackups(targetBase);
 
   console.log("Done! Next steps:");
   console.log("  1. Restart Ableton Live (or press Cmd+, to open Preferences)");
@@ -111,4 +217,4 @@ function uninstall() {
   }
 }
 
-module.exports = { install, uninstall };
+module.exports = { install, uninstall, InstallerAbort };

package/m4l_device/livepilot_bridge.js

@@ -95,7 +95,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.10.6"});
+            send_response({"ok": true, "version": "1.10.9"});
             break;
         case "get_params":
             cmd_get_params(args);

package/mcp_server/__init__.py

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

package/mcp_server/atlas/__init__.py

@@ -411,14 +411,46 @@ class AtlasManager:
 
 
 # ── Module-level lazy loader ───────────────────────────────────────
+#
+# Thread-safe via services.singletons.Singleton. The previous check-then-set
+# pattern raced under FastMCP concurrency (two handlers could both construct
+# AtlasManager) and never refreshed the in-memory index after a rebuild of
+# device_atlas.json on disk. The Singleton helper handles both.
+#
+# The ``_atlas_instance`` module attribute is preserved for backward
+# compatibility with call sites that read it directly (atlas/tools.py),
+# but new code should call ``get_atlas()`` / ``invalidate_atlas()`` instead.
 
-_atlas_instance: Optional[AtlasManager] = None
+from pathlib import Path
+from ..services.singletons import Singleton
 
+ATLAS_PATH = Path(__file__).parent / "device_atlas.json"
 
-def _load_atlas() -> AtlasManager:
-    """Lazy-load the atlas from device_atlas.json in the same directory."""
+_atlas_instance: Optional[AtlasManager] = None  # kept for legacy imports
+
+
+def _build_atlas() -> AtlasManager:
+    return AtlasManager(str(ATLAS_PATH))
+
+
+_atlas_holder = Singleton(_build_atlas)
+
+
+def get_atlas() -> AtlasManager:
+    """Thread-safe accessor. Re-reads device_atlas.json if its mtime advanced."""
     global _atlas_instance
-    if _atlas_instance is None:
-        atlas_path = os.path.join(os.path.dirname(__file__), "device_atlas.json")
-        _atlas_instance = AtlasManager(atlas_path)
-    return _atlas_instance
+    instance = _atlas_holder.get(reload_if_newer=ATLAS_PATH)
+    _atlas_instance = instance   # keep legacy attribute in sync
+    return instance
+
+
+def invalidate_atlas() -> None:
+    """Force the next get_atlas() to re-read device_atlas.json from disk."""
+    global _atlas_instance
+    _atlas_holder.invalidate()
+    _atlas_instance = None
+
+
+def _load_atlas() -> AtlasManager:
+    """Legacy shim — kept so atlas/tools.py still works. Prefer get_atlas()."""
+    return get_atlas()

package/mcp_server/atlas/tools.py

@@ -19,15 +19,17 @@ def _get_ableton(ctx: Context):
 
 
 def _get_atlas():
-    """Get the global AtlasManager instance, loading lazily if needed."""
-    from . import _atlas_instance, _load_atlas
-    if _atlas_instance is None:
-        try:
-            _load_atlas()
-        except FileNotFoundError:
-            return None
-    from . import _atlas_instance as inst
-    return inst
+    """Get the global AtlasManager instance, loading lazily if needed.
+
+    Uses the thread-safe singleton helper — concurrent FastMCP tool calls no
+    longer race on the check-then-set, and the atlas auto-reloads from disk
+    if device_atlas.json's mtime advanced (e.g. after scan_full_library).
+    """
+    from . import get_atlas
+    try:
+        return get_atlas()
+    except FileNotFoundError:
+        return None
 
 
 @mcp.tool()
@@ -197,23 +199,44 @@ def scan_full_library(ctx: Context, force: bool = False) -> dict:
         stats[cat] = stats.get(cat, 0) + 1
     stats["enriched_devices"] = sum(1 for d in devices if d.get("enriched"))
 
+    # Read the actual running Live version from the session rather than
+    # hardcoding "12.3.6" — the hardcoded string was baking last year's
+    # version into every new user's atlas until they forced a rescan.
+    try:
+        session_info = ableton.send_command("get_session_info", {}) or {}
+        live_version = session_info.get("live_version", "unknown")
+    except Exception:
+        live_version = "unknown"
+
     # Build atlas
     atlas_data = {
         "version": "2.0.0",
-        "live_version": "12.3.6",
+        "live_version": live_version,
         "scanned_at": time.strftime("%Y-%m-%dT%H:%M:%SZ"),
         "stats": stats,
         "devices": devices,
         "packs": [],
     }
 
-    # Write
-    with open(atlas_path, "w") as f:
+    # Atomic write: tmp + rename. Same pattern as PersistentJsonStore. Previous
+    # version used open(atlas_path, "w") + json.dump with no fsync, so a crash
+    # mid-write produced a truncated JSON file that the next AtlasManager init
+    # silently read as empty-dict — devices vanished from memory.
+    tmp_path = atlas_path + ".tmp"
+    with open(tmp_path, "w") as f:
         json.dump(atlas_data, f, indent=2)
-
-    # Reload into global
+        f.flush()
+        try:
+            os.fsync(f.fileno())
+        except OSError:
+            # fsync may be unavailable on some filesystems/Windows paths —
+            # best-effort; the rename below is still atomic on POSIX.
+            pass
+    os.replace(tmp_path, atlas_path)
+
+    # Invalidate singleton so next get_atlas() picks up the new file.
     import mcp_server.atlas as atlas_mod
-    atlas_mod._atlas_instance = AtlasManager(atlas_path)
+    atlas_mod.invalidate_atlas()
 
     return {
         "status": "scanned",
@@ -222,3 +245,21 @@ def scan_full_library(ctx: Context, force: bool = False) -> dict:
         "stats": stats,
         "atlas_path": atlas_path,
     }
+
+
+@mcp.tool()
+def reload_atlas(ctx: Context) -> dict:
+    """Force the atlas to re-read device_atlas.json from disk.
+
+    Useful after an out-of-band rebuild (e.g. a manual edit to the JSON file,
+    or a scan that crashed before invalidating the cache). The next search /
+    suggest / compare call will see the fresh data. No-op if the atlas has
+    never been loaded — the first real call will load it fresh anyway.
+    """
+    from . import invalidate_atlas, get_atlas
+    invalidate_atlas()
+    atlas = get_atlas()
+    return {
+        "reloaded": True,
+        "device_count": atlas.device_count if atlas else 0,
+    }

package/mcp_server/composer/layer_planner.py

@@ -403,6 +403,33 @@ def plan_sections(intent: CompositionIntent) -> list[dict]:
         })
         current_bar += scaled_bars
 
+    # Clamp overshoot. Rounding each section up to the nearest 4 bars plus
+    # the min-of-4-bars floor means a short duration_bars (e.g. 16) against
+    # a 6-section template could produce 24+ bars of sections — a 50%
+    # overshoot that pushed arrangement clips into unexpected territory.
+    # Trim from the longest non-intro section until we fit.
+    total_placed = sum(s["bars"] for s in sections)
+    overshoot = total_placed - intent.duration_bars
+    if overshoot > 0 and sections:
+        # Sort indices by section length desc, skipping the first section
+        # (usually intro) which we'd rather preserve at its snapped length.
+        trimmable = sorted(
+            range(1, len(sections)),
+            key=lambda i: -sections[i]["bars"],
+        ) or [0]
+        i = 0
+        while overshoot > 0 and i < len(trimmable) * 4:
+            idx = trimmable[i % len(trimmable)]
+            if sections[idx]["bars"] > 4:
+                sections[idx]["bars"] -= 4
+                overshoot -= 4
+            i += 1
+        # Recompute start_bar values after any trim
+        running = 0
+        for s in sections:
+            s["start_bar"] = running
+            running += s["bars"]
+
     return sections
 
 

package/mcp_server/composer/prompt_parser.py

@@ -202,9 +202,15 @@ _ELEMENT_PATTERNS: list[tuple[str, str]] = [
 
 _TEMPO_RE = re.compile(r"\b(\d{2,3})\s*bpm\b", re.IGNORECASE)
 
-# Key patterns: C, Cm, C#, C# minor, Db, Dbm, F# minor, Bb major
+# Key patterns: must have either an accidental (C#, Db) OR an explicit
+# quality word (C minor, F major, Am). The previous regex made the
+# quality group optional AND allowed a bare letter — so "dark ambient"
+# matched D as a key root, silently overwriting any mood-inferred key.
 _KEY_RE = re.compile(
-    r"\b([A-Ga-g][#b]?)\s*(minor|major|min|maj|m)?\b"
+    # Case 1: root + quality word (explicit minor/major/min/maj/m suffix)
+    r"\b([A-Ga-g])\s*(minor|major|min|maj|m)\b"
+    # Case 2: root + accidental (optional quality)
+    r"|\b([A-Ga-g][#b])\s*(minor|major|min|maj|m)?\b"
 )
 
 
@@ -228,19 +234,22 @@ def parse_prompt(text: str) -> CompositionIntent:
         intent.tempo = int(tempo_match.group(1))
 
     # 2. Extract key (search original text to preserve case)
+    # Regex has TWO alternations (root+quality OR root-with-accidental
+    # +optional-quality). Take whichever branch matched.
     key_match = _KEY_RE.search(text)
     if key_match:
-        root = key_match.group(1)
-        # Normalize root: uppercase first letter
+        root = key_match.group(1) or key_match.group(3)
+        quality = key_match.group(2) or key_match.group(4) or ""
+        # Normalize root: uppercase first letter, preserve accidental
         root = root[0].upper() + root[1:] if len(root) > 1 else root.upper()
-        quality = key_match.group(2) or ""
         quality_lower = quality.lower()
         if quality_lower in ("minor", "min", "m"):
             intent.key = f"{root}m"
         elif quality_lower in ("major", "maj"):
             intent.key = root
         else:
-            # Standalone note — check if followed by 'm' in the original
+            # Only reached when Case 2 matched without quality — an
+            # accidental was present (C#, Db), so this IS a legit key root.
             intent.key = root
 
     # 3. Match genre (check aliases first, then canonical names)

package/mcp_server/connection.py

@@ -213,9 +213,17 @@ class AbletonConnection:
             # The single-client guard can briefly reject an immediate reconnect
             # after this process closes a previous socket. Retry once after a
             # short delay when the command was rejected before execution.
-            if fresh_connect and _is_single_client_state_error(response):
-                self.disconnect()
-                time.sleep(SINGLE_CLIENT_RETRY_DELAY)
+            #
+            # IMPORTANT: release the lock around the sleep so concurrent tool
+            # calls are not blocked on an idle timer. The previous version
+            # slept 250ms while holding the lock, which stalled every other
+            # async MCP handler in the server.
+            needs_retry = fresh_connect and _is_single_client_state_error(response)
+
+        if needs_retry:
+            self.disconnect()
+            time.sleep(SINGLE_CLIENT_RETRY_DELAY)
+            with self._lock:
                 self.connect()
                 response = self._send_raw(
                     command,

package/mcp_server/corpus/__init__.py

@@ -365,13 +365,23 @@ def load_corpus() -> Corpus:
 
 
 # ── Module-level lazy singleton ─────────────────────────────────────────
+#
+# Thread-safe via services.singletons.Singleton — concurrent FastMCP
+# handlers can no longer both trigger load_corpus() (which did heavy
+# filesystem I/O) on a cold start.
 
+from ..services.singletons import Singleton
+
+_corpus_holder = Singleton(load_corpus)
+
+# Preserved for backward compatibility with any code that reads the legacy
+# attribute directly.
 _corpus_instance: Optional[Corpus] = None
 
 
 def get_corpus() -> Corpus:
-    """Get the global corpus instance (lazy-loaded on first call)."""
+    """Get the global corpus instance (lazy-loaded, thread-safe)."""
     global _corpus_instance
-    if _corpus_instance is None:
-        _corpus_instance = load_corpus()
-    return _corpus_instance
+    instance = _corpus_holder.get()
+    _corpus_instance = instance
+    return instance

package/mcp_server/evaluation/fabric.py

@@ -31,6 +31,66 @@ from .policy import apply_hard_rules
 # ── Sonic Evaluator ──────────────────────────────────────────────────
 
 
+def _compute_taste_fit(
+    dimension_changes: dict[str, dict],
+    outcome_history: Optional[list[dict]],
+) -> float:
+    """Score how well this move aligns with the user's recent taste.
+
+    Shipped in v1.10.9 — previously hardcoded to 0.0.
+
+    For each dimension that moved (in ``dimension_changes``), look at the
+    user's last few kept/undone outcomes for the same dimension:
+      * kept with the same direction of delta → +0.2 per match
+      * undone with the same direction of delta → −0.2 per match
+
+    Returns a value in 0..1 (0.5 = neutral, neither signal). Empty history
+    returns 0.5, which is the correct "no information yet" neutral the
+    composite score already expects.
+
+    ``outcome_history`` entries are dicts of the shape::
+
+        {"dimension": "punch", "delta": 0.12, "kept": True}
+
+    Callers that pass a richer shape should extract those three fields.
+    Malformed entries are skipped silently so a schema bump upstream can't
+    break the evaluator.
+    """
+    if not outcome_history or not dimension_changes:
+        return 0.5
+
+    # Only weigh the most recent slice — taste drifts, and older signals
+    # shouldn't veto a current evaluation.
+    recent = outcome_history[-10:]
+
+    adjustment = 0.0
+    matched = 0
+    for dim, change in dimension_changes.items():
+        current_delta = change.get("delta", 0.0)
+        current_sign = 1 if current_delta > 0 else (-1 if current_delta < 0 else 0)
+        if current_sign == 0:
+            continue
+        for entry in recent:
+            if not isinstance(entry, dict):
+                continue
+            if entry.get("dimension") != dim:
+                continue
+            past_delta = entry.get("delta")
+            if not isinstance(past_delta, (int, float)):
+                continue
+            past_sign = 1 if past_delta > 0 else (-1 if past_delta < 0 else 0)
+            if past_sign != current_sign:
+                continue
+            kept = bool(entry.get("kept", False))
+            adjustment += 0.2 if kept else -0.2
+            matched += 1
+
+    if matched == 0:
+        return 0.5
+    # Neutral baseline 0.5 + averaged adjustment, clamped to [0, 1].
+    return _clamp(0.5 + adjustment / matched)
+
+
 def evaluate_sonic_move(
     request: EvaluationRequest,
     outcome_history: Optional[list[dict]] = None,
@@ -109,12 +169,13 @@ def evaluate_sonic_move(
     measurable_component = _clamp(0.5 + measurable_delta)
     preservation = _clamp(1.0 - collateral_damage * 5)
     confidence = measurable_count / max(len(targets), 1)
+    taste_fit = _compute_taste_fit(dimension_changes, outcome_history)
 
     score = (
         0.30 * goal_fit
         + 0.25 * measurable_component
         + 0.15 * preservation
-        + 0.10 * 0.0   # taste_fit: placeholder, no history in fabric v1
+        + 0.10 * taste_fit
         + 0.10 * confidence
         + 0.10 * 1.0   # reversibility: 1.0 for undo-able moves
     )