livepilot 1.27.0 → 1.27.1

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # Changelog
 
+## v1.27.1 — 2026-06-21
+
+Maintenance release: 35 verified fixes from a deep multi-agent audit, recursive installed-plugin scanning, and Windows-CI hardening. No change to the tool surface (467 tools / 56 domains).
+
+### Restored — tools that were silently broken
+- `augment_with_samples`, `get_composition_plan`, `propose_composer_branches` — crashed or returned nothing since the v1.24 refactor removed section templates; they now degrade to a single full-length section.
+- `check_clip_key_consistency` — always returned `"unknown"` (removed FastMCP `.fn` accessor).
+- `compare_phrase_renders` — returned an identical empty critique; now analyzes each render.
+
+### Fixed — correctness
+- Reference engine: project spectrum and stereo width are now populated (gap analysis previously ran against an all-zero project).
+- `infer_section_purposes`: drops are no longer mislabeled as tension.
+- Grader: master/return/group tracks identified by their real field names (group containers were inflating track counts).
+- Hook salience: the memorability boost no longer fires on every candidate.
+- Mix: the `flat_dynamics` critic is now reachable (`over_compressed` is a 3–6 dB band).
+- Wavetable adapter uses the real `Osc 1 Pos` parameter name.
+- Simpler slice playback uses the correct base note (36+N); `vibe_fit` energy proxy normalized.
+- Harmony and phrase-grid analysis read from the correct clip slot.
+- `exclude_globs` now match files inside named directories.
+- A single shared technique store so in-session saves are visible to recall/search.
+- Read-only prefix matcher no longer misclassifies mutating tools as safe.
+- Atlas id/name collisions no longer shadow entries; the overlay index is no longer rescanned per namespace.
+- AMXD device-type map recognizes MIDI Tool devices (Live 12.1+).
+- `apply_full_plan_v2` postflight no longer deletes a reused existing track.
+- Fatigue level no longer diluted by low-severity issues; energy-arc no longer desyncs on skipped scenes; `create_preview_set` no longer silently overwrites an existing set.
+
+### Fixed — installed-plugin scanning (#44)
+- The plugin scanner now recurses into vendor subfolders (e.g. `VST3/<Vendor>/Plugin.vst3`); nested plugins are found and vendor folders are no longer emitted as junk inventory records.
+
+### Fixed — safety and resources
+- Splice `is_free` misclassification that could bypass credit/quota gating.
+- Experiment rollback undoes only `remote_command` steps (no longer reverts unrelated edits).
+- Timed-out write commands are dropped instead of re-executing later on the main thread.
+- Order-tolerant M4L bridge chunk reassembly (no permanent response loss on UDP reordering).
+- Installer install-path guard hardened; Splice bearer token gated to splice.com HTTPS hosts; non-numeric Live version strings tolerated instead of crashing the capability probe.
+
+### Performance
+- Blocking sample I/O (SQLite, file decode, FFT, network) moved off the asyncio event loop.
+- Capped previously-unbounded tool responses (`atlas_device_info`, `extension_atlas_search`, corpus synthesis briefs, piano-roll matrix, plugin `sdk_metadata`).
+- Deduped redundant session round-trips (`enter_wonder_mode`, `build_project_brain`).
+
+### CI and tooling
+- Fixed the Windows CI matrix (cp1252 `UnicodeEncodeError` in verifier scripts; POSIX-path test fixture).
+- `build_mcpb.sh` enforces `.mcpbignore`; portable dev scripts.
+
+### Dependencies
+- fastmcp, soundfile 0.14.0, grpcio 1.81.1, protobuf 7.35.1.
+
 ## v1.27.0 — 2026-06-16
 
 Probe-first Live 12.4 capability release.

package/README.md

@@ -38,6 +38,20 @@
 
 ---
 
+## What's New in v1.27.1
+
+A maintenance release that fixes 35 issues from a deep audit and restores tools that had silently broken:
+
+- **Restored tools** — `augment_with_samples`, `get_composition_plan`, `propose_composer_branches`, `check_clip_key_consistency`, and `compare_phrase_renders` were crashing or returning empty results; they now work.
+- **Recursive plugin scanning (#44)** — the User Corpus scanner now finds plugins nested in vendor subfolders (e.g. `VST3/<Vendor>/Plugin.vst3`) instead of only the top level.
+- **Truer analysis** — reference-gap, hook-salience, dynamics, drop-detection, harmony-slot, and grader fixes that previously produced fabricated or empty results.
+- **Safer & faster** — Splice credit-gating fixed, blocking sample I/O moved off the event loop, unbounded tool responses capped, and the M4L bridge no longer loses responses on UDP reordering.
+- **v1.27.0** added two read-only Live 12.4 capability-probe tools (`probe_link_audio`, `probe_stem_workflow`).
+
+Full details in the [CHANGELOG](CHANGELOG.md).
+
+---
+
 ## What LivePilot Does
 
 Most MCP servers are tool collections — they execute commands. LivePilot is an **agentic production system**. It has eight layers that work together:
@@ -473,7 +487,7 @@ Full track with song form: intro, verse, hook, breakdown, outro. Uses a two-phas
 - Native arrangement clips via `create_native_arrangement_clip` (one clip per section, looped to fill section length)
 - Zombie-track cleanup in postflight (removes tracks with no clips and no instrument device)
 - Drum-role pitch repair ported from fast mode
-- **Known gap (v1.25):** `KnowledgePack.atlas_candidates_per_role` is an empty stub — the agent currently falls through to `search_browser` filename matching instead of consulting the indexed atlas. This is BUG-FULL-MODE-24 and is the headline feature of v1.25.
+- **Atlas anchors:** role-level device knowledge is supplied through `KnowledgePack.atlas_anchors`, which consults the indexed atlas rather than filename matching. The older `atlas_candidates_per_role` field is a deprecated legacy stub, kept empty for back-compat.
 - Invoke with: *"Write a full [genre] track at [tempo] BPM"* or *"Build a full arrangement"*
 
 #### develop mode — `develop_apply`
@@ -492,7 +506,7 @@ All three modes share a `KnowledgePack` that provides structured creative contex
 - `event_lexicon` — 42 structural events across 7 categories (drum density, harmonic, texture, vocal, rhythm feel, tension, fx gesture)
 - `genre_context` — parses the 15-genre `genre-vocabularies.md` at load time
 - `artist_context` — parses the ~25-producer `artist-vocabularies.md` at load time
-- `atlas_candidates_per_role` — **stubbed in v1.25.0**, will be populated in v1.25
+- `atlas_anchors` — indexed-atlas device anchors per role (replaced the legacy `atlas_candidates_per_role` stub)
 
 #### Core composer tools
 
@@ -550,7 +564,7 @@ The V2 intelligence layer. These tools analyze, diagnose, plan, evaluate, and le
 
 ### Easiest: Claude Desktop Extension (1 click)
 
-Download [`livepilot.mcpb`](https://github.com/dreamrec/LivePilot/releases/latest) and double-click it.
+Download the latest `livepilot-<version>.mcpb` from the [Releases page](https://github.com/dreamrec/LivePilot/releases/latest) and double-click it.
 Claude Desktop installs everything automatically. Then:
 
 1. Open Ableton Live 12
@@ -584,10 +598,14 @@ Restart Ableton → Preferences → Link, Tempo & MIDI → Control Surface → *
 <details>
 <summary><strong>2. MCP Client</strong></summary>
 
-**Claude Code:**
+**Claude Code** — pick one (installing both registers the MCP server twice and collides on port 9878):
 ```bash
+# MCP server only:
 claude mcp add LivePilot -- npx livepilot
-claude plugin add github:dreamrec/LivePilot/plugin
+
+# Or the full plugin (MCP server + skills + slash commands):
+claude plugin marketplace add github:dreamrec/LivePilot
+claude plugin install livepilot@dreamrec-LivePilot
 ```
 
 **Codex App:**
@@ -680,7 +698,8 @@ npx livepilot --install-codex-plugin
 **Claude Code**
 
 ```bash
-claude plugin add github:dreamrec/LivePilot/plugin
+claude plugin marketplace add github:dreamrec/LivePilot
+claude plugin install livepilot@dreamrec-LivePilot
 ```
 
 | Command | What |

package/bin/livepilot.js

@@ -823,8 +823,10 @@ async function main() {
     console.log("  --help        Show this help");
     console.log("");
     console.log("Environment:");
-    console.log("  LIVE_MCP_HOST   Remote Script host (default: 127.0.0.1)");
-    console.log("  LIVE_MCP_PORT   Remote Script port (default: 9878)");
+    console.log("  LIVE_MCP_HOST          Remote Script host (default: 127.0.0.1)");
+    console.log("  LIVE_MCP_PORT          Remote Script port (default: 9878)");
+    console.log("  LIVEPILOT_AUTO_INSTALL Auto-install Remote Script on launch (set to 'true')");
+    console.log("  LIVEPILOT_TCP_PORT     Override Remote Script port (Desktop Extension/MCPB)");
     return;
   }
 

package/installer/install.js

@@ -46,23 +46,32 @@ function _assertSafeInstallPath(resolvedPath, candidates) {
     "/Applications/Ableton",
     "C:\\ProgramData\\Ableton",
   ];
-  // The detected Ableton candidate paths are always considered safe
+  // True iff `child` equals `root` or is a descendant of it. The path.sep
+  // suffix prevents `/Applications/Ableton-evil` from matching the
+  // `/Applications/Ableton` prefix (prefix-boundary check).
+  const within = (child, root) => {
+    const c = path.resolve(child);
+    const r = path.resolve(root);
+    return c === r || c.startsWith(r + path.sep);
+  };
+  // The destination must be a detected Ableton Remote Scripts dir, a descendant
+  // of one, or under a known-safe prefix. We deliberately do NOT treat an
+  // *ancestor* of a candidate as safe — that previously let
+  // LIVEPILOT_INSTALL_PATH=/ or /Applications slip through (candidate path
+  // "starts with" the broad parent), defeating the guard.
   for (const c of candidates) {
-    if (path.resolve(c.path).startsWith(path.resolve(resolvedPath))) {
-      return;
-    }
-    if (path.resolve(resolvedPath).startsWith(path.resolve(c.path))) {
+    if (within(resolvedPath, 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 }
-    );
+  if (allowedPrefixes.some((p) => within(resolvedPath, p))) {
+    return;
   }
+  throw new InstallerAbort(
+    `LIVEPILOT_INSTALL_PATH=${resolvedPath} is outside permitted directories. ` +
+    `Refusing to install. Allowed roots: ${allowedPrefixes.join(", ")}`,
+    { recoverable: false }
+  );
 }
 
 /**

package/livepilot/.Codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.27.0",
+  "version": "1.27.1",
   "description": "Agentic production system for Ableton Live 12 \u2014 467 tools, 56 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, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": {
     "name": "Pilot Studio"

package/livepilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.27.0",
+  "version": "1.27.1",
   "description": "Agentic production system for Ableton Live 12 \u2014 467 tools, 56 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, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": {
     "name": "Pilot Studio"

package/livepilot/skills/livepilot-core/SKILL.md

@@ -198,14 +198,14 @@ Use when the user wants options, variants, or is stuck ("surprise me", "try some
 **Rule of thumb**: if the user asked for a specific fix, Flow A. If they asked "what would you do?" or mentioned feel/vibe without parameters, Flow B.
 
 ### Semantic Moves
-High-level musical intents that compile to deterministic tool sequences. 7 families (44 moves as of v1.27.0):
-- **mix** — `tighten_low_end`, `widen_stereo`, `make_punchier`, `darken_without_losing_width`, `reduce_repetition_fatigue`, `make_kick_bass_lock`, `reduce_foreground_competition`
-- **arrangement** — `refresh_repeated_section`, plus structural moves defined alongside mix
-- **transition** — `create_buildup_tension`, `smooth_scene_handoff`, `increase_contrast_before_payoff`, `bridge_sections`, `increase_forward_motion`, `open_chorus`, `create_breakdown`
-- **sound_design** — `add_warmth`, `add_texture`, `shape_transients`, `add_space`
-- **performance** — `recover_energy`, `decompress_tension`, `safe_spotlight`, `emergency_simplify`
-- **device_creation** — `create_chaos_modulator`, `create_feedback_resonator`, `create_wavefolder_effect`, `create_bitcrusher_effect`, `create_karplus_string`, `create_stochastic_texture`, `create_fdn_reverb` (procedural M4L device generation)
-- **sample** — `sample_chop_rhythm`, `sample_texture_layer`, `sample_vocal_ghost`, `sample_break_layer`, `sample_resample_destroy`, `sample_one_shot_accent` (registered from `sample_engine/moves.py`)
+High-level musical intents that compile to deterministic tool sequences. 7 families (44 moves as of v1.27.1):
+- **mix** (9) — `tighten_low_end`, `widen_stereo`, `make_punchier`, `darken_without_losing_width`, `reduce_repetition_fatigue`, `make_kick_bass_lock`, `set_track_routing`, `set_track_metadata`, `configure_send_architecture`
+- **device_creation** (9) — `create_chaos_modulator`, `create_feedback_resonator`, `create_wavefolder_effect`, `create_bitcrusher_effect`, `create_karplus_string`, `create_stochastic_texture`, `create_fdn_reverb`, `create_drum_rack_pad`, `build_send_chain` (procedural M4L device generation)
+- **sound_design** (7) — `add_warmth`, `add_texture`, `shape_transients`, `add_space`, `configure_device`, `remove_device`, `load_chord_source`
+- **sample** (6) — `sample_chop_rhythm`, `sample_texture_layer`, `sample_vocal_ghost`, `sample_break_layer`, `sample_resample_destroy`, `sample_one_shot_accent` (registered from `sample_engine/moves.py`)
+- **performance** (5) — `recover_energy`, `decompress_tension`, `safe_spotlight`, `emergency_simplify`, `configure_record_readiness`
+- **arrangement** (4) — `create_buildup_tension`, `smooth_scene_handoff`, `configure_groove`, `set_scene_metadata`
+- **transition** (4) — `bridge_sections`, `increase_forward_motion`, `open_chorus`, `create_breakdown`
 
 Use `list_semantic_moves(domain="mix")` to discover available moves.
 

package/livepilot/skills/livepilot-core/references/overview.md

@@ -1,4 +1,4 @@
-# LivePilot v1.27.0 — Architecture & Tool Reference
+# LivePilot v1.27.1 — Architecture & Tool Reference
 
 Agentic production system for Ableton Live 12. 467 tools across 56 domains. Device atlas (5264 devices, 120 enriched, 47 with aesthetic-tagged `signature_techniques`), spectral perception (M4L analyzer with 9-band FFT — sub_low / sub / low / low_mid / mid / high_mid / high / presence / air), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift, additive process), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O, **LIVE Splice describe-a-sound + variations via captured GraphQL endpoints (v1.17)**, drum-rack pad-by-pad construction, live dead-device detection via meter sampling, role-aware Simpler defaults, session-record arrangement-automation workaround.
 
@@ -218,7 +218,7 @@ This turns "set EQ band 3 to -4 dB" into "cut 400 Hz by 4 dB, then read the spec
 | `memory_update` | Updates name, tags, or qualities | `technique_id`, `name`, `tags`, `qualities` |
 | `memory_delete` | Removes technique (backs up first) | `technique_id` |
 
-### Analyzer (30) — Real-time DSP analysis (requires LivePilot Analyzer M4L device on master track)
+### Analyzer (38) — Real-time DSP analysis (requires LivePilot Analyzer M4L device on master track)
 
 | Tool | What it does | Key params |
 |------|-------------|------------|

package/livepilot/skills/livepilot-evaluation/references/capability-modes.md

@@ -173,7 +173,7 @@ Live 12.4 introduces a new capability tier that unlocks native LOM access for sa
 **Tool signatures:** unchanged. Callers do not need to detect the tier —
 routing is transparent.
 
-**Probe-first 12.4 surfaces in v1.27.0:**
+**Probe-first 12.4 surfaces in v1.27.1:**
 - `probe_link_audio()` reports observed peer/input/routing visibility and
   returns `manual_only`, `readable`, `routable`, or `unavailable`.
 - `probe_stem_workflow()` reports observed callable paths and returns

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.27.0";
+var VERSION = "1.27.1";
 
 // ── State ──────────────────────────────────────────────────────────────────
 

package/mcp_server/__init__.py

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

package/mcp_server/atlas/__init__.py

@@ -7,9 +7,12 @@ suggestion, chain building, and device comparison.
 from __future__ import annotations
 
 import json
+import logging
 import os
 from typing import Any, Dict, List, Optional
 
+logger = logging.getLogger(__name__)
+
 
 class AtlasManager:
     """In-memory device atlas with indexed lookups."""
@@ -47,10 +50,26 @@ class AtlasManager:
             dev_category = dev.get("category", "")
 
             if dev_id:
+                if dev_id in self._by_id and self._by_id[dev_id] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device id %r shadows a prior entry "
+                        "(name=%r); last-wins", dev_id, dev_name,
+                    )
                 self._by_id[dev_id] = dev
             if dev_name:
-                self._by_name[dev_name.lower()] = dev
+                name_key = dev_name.lower()
+                if name_key in self._by_name and self._by_name[name_key] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device name %r shadows a prior entry "
+                        "(id=%r); last-wins", dev_name, dev_id,
+                    )
+                self._by_name[name_key] = dev
             if dev_uri:
+                if dev_uri in self._by_uri and self._by_uri[dev_uri] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device uri %r shadows a prior entry "
+                        "(id=%r); last-wins", dev_uri, dev_id,
+                    )
                 self._by_uri[dev_uri] = dev
 
             # Category index

package/mcp_server/atlas/tools.py

@@ -109,11 +109,14 @@ def atlas_search(ctx: Context, query: str, category: str = "all", limit: int = 1
     try:
         from .overlays import get_overlay_index
         idx = get_overlay_index()
-        # Search all non-`packs` namespaces; `packs` is already in the bundled atlas
-        for ns in idx.list_namespaces():
-            if ns == "packs":
-                continue
-            overlay_results.extend(idx.search(query, namespace=ns, limit=limit))
+        # Single pass over the overlay index (namespace=None scans all
+        # namespaces at once), then drop `packs` client-side — `packs` is
+        # already covered by the bundled atlas. Avoids re-scanning the whole
+        # index once per namespace.
+        overlay_results = [
+            e for e in idx.search(query, namespace=None, limit=limit * 2)
+            if e.namespace != "packs"
+        ]
     except Exception:  # noqa: BLE001 — never fail atlas_search over an overlay glitch
         pass
 
@@ -177,10 +180,13 @@ def atlas_search(ctx: Context, query: str, category: str = "all", limit: int = 1
 
 
 @mcp.tool()
-def atlas_device_info(ctx: Context, device_id: str) -> dict:
+def atlas_device_info(ctx: Context, device_id: str, verbose: bool = True) -> dict:
     """Get complete atlas knowledge about a device — parameters, recipes, pairings, gotchas.
 
     device_id: the atlas ID or device name (e.g., "drift", "Compressor", "808_core_kit")
+    verbose:   when True (default) return the full raw atlas record. Set False for a
+               compact summary (capped description, tag/technique counts) — useful
+               when you only need to identify the device, not read every recipe.
     """
     atlas = _get_atlas()
     if atlas is None:
@@ -189,7 +195,29 @@ def atlas_device_info(ctx: Context, device_id: str) -> dict:
     entry = atlas.lookup(device_id)
     if entry is None:
         return {"error": f"Device '{device_id}' not found in atlas", "suggestion": "Use atlas_search to find devices"}
-    return entry
+    if verbose:
+        return entry
+    # Compact mode: the common case doesn't need the full multi-KB record.
+    # Truncate the longest free-text fields the way atlas_search already caps
+    # sonic_description, and report counts for list-heavy fields so the caller
+    # knows to re-request verbose for the full detail.
+    summary: dict = {
+        "id": entry.get("id", ""),
+        "name": entry.get("name", ""),
+        "uri": entry.get("uri", ""),
+        "category": entry.get("category", ""),
+        "enriched": bool(entry.get("enriched", False)),
+        "sonic_description": (
+            entry.get("sonic_description") or entry.get("description", "")
+        )[:_ATLAS_SEARCH_DESCRIPTION_CHAR_CAP],
+        "character_tags": (
+            entry.get("character_tags") or entry.get("tags", [])
+        )[:8],
+        "sweet_spot": str(entry.get("sweet_spot", ""))[:_ATLAS_SEARCH_DESCRIPTION_CHAR_CAP],
+    }
+    summary.update(_surface_enriched_fields(entry))
+    summary["verbose_available"] = True
+    return summary
 
 
 @mcp.tool()
@@ -258,20 +286,20 @@ def atlas_chain_suggest(ctx: Context, role: str, genre: str = "") -> dict:
             query_parts.append(genre)
         query = " ".join(query_parts)
 
-        for ns in idx.list_namespaces():
-            if ns == "packs":
-                continue
-            hits = idx.search(query, namespace=ns, limit=5)
-            for entry in hits:
-                overlay_suggestions.append({
+        hits = [
+            e for e in idx.search(query, namespace=None, limit=10)
+            if e.namespace != "packs"
+        ]
+        for entry in hits:
+            overlay_suggestions.append({
                     "namespace": entry.namespace,
                     "entity_id": entry.entity_id,
                     "name": entry.name,
                     "description": (entry.description or "")[:120],
                     "tags": list(entry.tags)[:5],
-                    "source": f"user_overlay:{entry.namespace}",
-                    "note": "Load via search_browser or extension_atlas_get; no Live URI.",
-                })
+                "source": f"user_overlay:{entry.namespace}",
+                "note": "Load via search_browser or extension_atlas_get; no Live URI.",
+            })
     except Exception:  # noqa: BLE001 — never fail chain_suggest over an overlay glitch
         pass
 
@@ -662,14 +690,17 @@ def scan_full_library(
     if not force and os.path.exists(atlas_path):
         age = time.time() - os.path.getmtime(atlas_path)
         if age < 86400:
-            # Reload if not already loaded
-            import mcp_server.atlas as atlas_mod
-            if atlas_mod._atlas_instance is None:
-                atlas_mod._atlas_instance = AtlasManager(atlas_path)
+            # Use the public, thread-safe loader rather than poking the
+            # legacy `_atlas_instance` cell directly: get_atlas() loads
+            # lazily via the Singleton holder and is the only path the rest
+            # of the module actually reads back from. The old direct
+            # AtlasManager(atlas_path) construction wrote a cell get_atlas()
+            # never consults.
+            from . import get_atlas
             return {
                 "status": "already_exists",
                 "age_hours": round(age / 3600, 1),
-                "device_count": atlas_mod._atlas_instance.device_count,
+                "device_count": get_atlas().device_count,
                 "message": "Atlas is recent. Use force=True to rescan.",
             }
 
@@ -796,6 +827,34 @@ def _serialize_overlay_entry(entry) -> dict:
     }
 
 
+_OVERLAY_DESCRIPTION_PREVIEW = 240
+
+
+def _serialize_overlay_entry_lite(entry) -> dict:
+    """Lightweight search-result serializer: drops the full YAML `body`.
+
+    The `body` of an overlay entry can be ~17 KB; inlining it for every one of
+    up to `limit` matches makes a single extension_atlas_search return hundreds
+    of KB. The search path only needs identity + a description preview so the
+    caller can decide which entry to fetch in full via extension_atlas_get.
+    """
+    description = entry.description or ""
+    truncated = len(description) > _OVERLAY_DESCRIPTION_PREVIEW
+    return {
+        "namespace": entry.namespace,
+        "entity_type": entry.entity_type,
+        "entity_id": entry.entity_id,
+        "name": entry.name,
+        "description": (
+            description[:_OVERLAY_DESCRIPTION_PREVIEW] + "…"
+            if truncated else description
+        ),
+        "tags": entry.tags,
+        "artists": entry.artists,
+        "requires_box": entry.requires_box,
+    }
+
+
 @mcp.tool()
 def extension_atlas_search(ctx: Context, query: str,
                            namespace: str = "",
@@ -822,7 +881,9 @@ def extension_atlas_search(ctx: Context, query: str,
         "namespace": namespace or None,
         "entity_type": entity_type or None,
         "count": len(matches),
-        "results": [_serialize_overlay_entry(e) for e in matches],
+        "results": [_serialize_overlay_entry_lite(e) for e in matches],
+        "note": "Search results omit the full YAML body; call "
+                "extension_atlas_get(namespace, entity_id) for the complete entry.",
     }
 
 

package/mcp_server/composer/full/apply.py

@@ -719,6 +719,15 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 continue
         else:
             track_index = int(track_index)
+            # BUG-FIX (P2 zombie-cleanup): a reused/existing track must also be
+            # registered as "applied". Otherwise the postflight zombie-cleanup
+            # (which excludes only applied_track_indices) sees a reused track
+            # that currently has no session clips / instrument — e.g. one given
+            # only arrangement clips — as an empty leftover and DELETES it.
+            # Reused tracks must never be eligible for cleanup, and postflight
+            # monitoring must be restored on them too.
+            if track_index >= 0 and track_index not in applied_track_indices:
+                applied_track_indices.append(track_index)
 
         # Optional instrument load
         instrument = track_spec.get("instrument") or {}

package/mcp_server/composer/full/layer_planner.py

@@ -408,12 +408,22 @@ def plan_sections(
     Returns a list of dicts: {name, bars, layers, start_bar}.
     """
     if section_template is None:
-        raise ValueError(
-            "plan_sections() requires explicit section_template in v1.24+. "
-            "SECTION_TEMPLATES was removed — the LLM provides form, not the "
-            "framework. Pass a section_template list or use the v1.24 full-mode "
-            "compose flow which is LLM-creative."
-        )
+        # v1.24 removed the built-in SECTION_TEMPLATES registry (form is the
+        # LLM's job, not the framework's). But the deterministic scaffolding
+        # tools (augment_with_samples, get_composition_plan,
+        # propose_composer_branches) and wonder_mode still call this without a
+        # template. Degrade to a SINGLE full-length section containing every
+        # selected role — this is NOT a form template (no genre-keyed
+        # multi-section sequence, no module-level bar-count registry), it just
+        # lets those tools emit a working skeleton. Callers that want real form
+        # pass an explicit section_template.
+        roles = _select_roles(intent)
+        return [{
+            "name": "Full",
+            "bars": max(4, int(intent.duration_bars or 64)),
+            "layers": list(roles),
+            "start_bar": 0,
+        }]
 
     template = section_template
 

package/mcp_server/creative_constraints/engine.py

@@ -72,9 +72,28 @@ def validate_plan_against_constraints(
     session_info = session_info or {}
     violations: list[str] = []
     warnings: list[str] = []
+    unenforced: list[str] = []
 
     steps = plan.get("steps", [])
 
+    # Modes that carry no structural step-level rule (taste/heuristic only).
+    # They were previously skipped silently — surface them as warnings so a
+    # caller can't mistake "no violations" for "validated against this mode".
+    advisory_modes = {
+        "mood_shift_without_new_fx": (
+            "shift the mood with existing tools — adding effects is discouraged "
+            "but not auto-detected here"
+        ),
+        "make_it_stranger_but_keep_the_hook": (
+            "push novelty while preserving the hook — not enforceable from plan "
+            "steps alone"
+        ),
+        "club_translation_safe": (
+            "keep changes club/DJ-friendly — judged by mix/tempo character, not "
+            "individual steps"
+        ),
+    }
+
     for constraint in constraint_set.constraints:
         if constraint == "no_new_tracks":
             for step in steps:
@@ -96,10 +115,37 @@ def validate_plan_against_constraints(
                 if step.get("action", "") in mix_actions:
                     violations.append(f"Step modifies mix ({step['action']}) — violates arrangement_only")
 
+        elif constraint == "use_loaded_devices_only":
+            load_actions = {"load_browser_item", "insert_device", "find_and_load_device",
+                           "load_device_by_uri", "load_sample_to_simpler",
+                           "replace_simpler_sample", "insert_rack_chain"}
+            for step in steps:
+                if step.get("action", "") in load_actions:
+                    violations.append(
+                        f"Step loads a new device ({step['action']}) — violates use_loaded_devices_only"
+                    )
+
+        elif constraint == "performance_safe_creative":
+            unsafe_actions = {"create_midi_track", "create_audio_track", "create_return_track",
+                             "delete_track", "delete_device", "delete_clip", "delete_scene"}
+            for step in steps:
+                if step.get("action", "") in unsafe_actions:
+                    violations.append(
+                        f"Step is unsafe during live performance ({step['action']}) — "
+                        f"violates performance_safe_creative"
+                    )
+
+        elif constraint in advisory_modes:
+            unenforced.append(constraint)
+            warnings.append(
+                f"{constraint} is advisory: {advisory_modes[constraint]}"
+            )
+
     return {
         "valid": len(violations) == 0,
         "violations": violations,
         "warnings": warnings,
+        "unenforced_constraints": unenforced,
         "constraint_count": len(constraint_set.constraints),
     }
 

package/mcp_server/experiment/engine.py

@@ -244,12 +244,19 @@ async def run_branch_async(
     ]
 
     steps_executed = sum(1 for r in exec_results if r.ok)
+    # Only remote_command steps land on Ableton's linear undo stack. Bridge
+    # (M4L/OSC) and mcp_tool mutations do NOT, so issuing one `undo` per
+    # successful step over-undoes and walks back unrelated prior user edits.
+    # Count undos from remote_command successes alone.
+    undo_count = sum(
+        1 for r in exec_results if r.ok and r.backend == "remote_command"
+    )
     branch.executed_at_ms = int(time.time() * 1000)
     branch.after_snapshot = capture_fn()
 
-    # Undo all successful steps back to checkpoint. Undo is a remote_command,
-    # route it through the normal ableton.send_command path for simplicity.
-    for _ in range(steps_executed):
+    # Undo only the remote_command steps back to checkpoint. Undo is itself a
+    # remote_command, routed through the normal ableton.send_command path.
+    for _ in range(undo_count):
         try:
             ableton.send_command("undo", {})
         except Exception as exc: