livepilot 1.9.15 → 1.9.16

package/mcp_server/runtime/tools.py

@@ -9,8 +9,11 @@ from __future__ import annotations
 from fastmcp import Context
 
 from ..server import mcp
+from ..memory.technique_store import TechniqueStore
 from .capability_state import build_capability_state
 
+_memory_store = TechniqueStore()
+
 
 @mcp.tool()
 def get_capability_state(ctx: Context) -> dict:
@@ -40,11 +43,11 @@ def get_capability_state(ctx: Context) -> dict:
             snap = spectral.get("spectrum")
             analyzer_fresh = snap is not None
 
-    # ── Probe memory ────────────────────────────────────────────────
+    # ── Probe memory (direct TechniqueStore, not TCP) ────────────────
     memory_ok = False
     try:
-        mem_result = ableton.send_command("memory_list", {"type": "technique"})
-        memory_ok = isinstance(mem_result, dict) and "error" not in mem_result
+        _memory_store.list_techniques(limit=1)
+        memory_ok = True
     except Exception:
         memory_ok = False
 

package/mcp_server/tools/agent_os.py

@@ -15,8 +15,11 @@ from typing import Optional
 from fastmcp import Context
 
 from ..server import mcp
+from ..memory.technique_store import TechniqueStore
 from . import _agent_os_engine as engine
 
+_memory_store = TechniqueStore()
+
 
 def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
@@ -268,25 +271,25 @@ def analyze_outcomes(
     The more outcomes stored (via memory_learn type="outcome"),
     the better the taste analysis becomes.
     """
-    ableton = _get_ableton(ctx)
-
-    # Fetch outcome memories
+    # Fetch outcome memories directly from TechniqueStore
     try:
-        memory_result = ableton.send_command("memory_list", {
-            "type": "outcome",
-            "limit": limit,
-            "sort_by": "updated_at",
-        })
-        techniques = memory_result.get("techniques", [])
+        techniques = _memory_store.list_techniques(
+            type_filter="outcome", sort_by="updated_at", limit=limit,
+        )
     except Exception:
         techniques = []
 
-    # Extract payloads from techniques
+    # Extract payloads from full technique records
     outcomes = []
     for t in techniques:
-        payload = t.get("payload", {})
-        if isinstance(payload, dict):
-            outcomes.append(payload)
+        # list_techniques returns compact summaries; get full record for payload
+        try:
+            full = _memory_store.get(t["id"])
+            payload = full.get("payload", {})
+            if isinstance(payload, dict):
+                outcomes.append(payload)
+        except Exception:
+            pass
 
     return engine.analyze_outcome_history(outcomes)
 
@@ -308,29 +311,30 @@ def get_technique_card(
     query: search term (e.g., "wider pad", "punchy kick", "sidechain bass")
     limit: max results
     """
-    ableton = _get_ableton(ctx)
-
+    # Search technique cards directly from TechniqueStore
     try:
-        memory_result = ableton.send_command("memory_recall", {
-            "query": query,
-            "type": "technique_card",
-            "limit": limit,
-        })
-        techniques = memory_result.get("techniques", [])
+        techniques = _memory_store.search(
+            query=query, type_filter="technique_card", limit=limit,
+        )
     except Exception:
         techniques = []
 
     cards = []
     for t in techniques:
-        payload = t.get("payload", {})
-        if isinstance(payload, dict):
-            cards.append({
-                "id": t.get("id"),
-                "name": t.get("name"),
-                "card": payload,
-                "rating": t.get("rating", 0),
-                "replay_count": t.get("replay_count", 0),
-            })
+        # search() returns summaries without payload; get full record
+        try:
+            full = _memory_store.get(t["id"])
+            payload = full.get("payload", {})
+            if isinstance(payload, dict):
+                cards.append({
+                    "id": t.get("id"),
+                    "name": t.get("name"),
+                    "card": payload,
+                    "rating": t.get("rating", 0),
+                    "replay_count": t.get("replay_count", 0),
+                })
+        except Exception:
+            pass
 
     return {
         "query": query,
@@ -358,19 +362,23 @@ def get_taste_profile(
     Returns: {taste_vector, preferred_dimensions, avoided_dimensions,
               keep_rate, sample_size}
     """
-    ableton = _get_ableton(ctx)
-
+    # Fetch outcome memories directly from TechniqueStore
     try:
-        memory_result = ableton.send_command("memory_list", {
-            "type": "outcome",
-            "limit": limit,
-            "sort_by": "updated_at",
-        })
-        techniques = memory_result.get("techniques", [])
+        techniques = _memory_store.list_techniques(
+            type_filter="outcome", sort_by="updated_at", limit=limit,
+        )
     except Exception:
         techniques = []
 
-    outcomes = [t.get("payload", {}) for t in techniques if isinstance(t.get("payload"), dict)]
+    outcomes = []
+    for t in techniques:
+        try:
+            full = _memory_store.get(t["id"])
+            payload = full.get("payload", {})
+            if isinstance(payload, dict):
+                outcomes.append(payload)
+        except Exception:
+            pass
 
     return engine.get_taste_profile(outcomes)
 

package/mcp_server/tools/composition.py

@@ -19,8 +19,11 @@ from typing import Optional
 from fastmcp import Context
 
 from ..server import mcp
+from ..memory.technique_store import TechniqueStore
 from . import _composition_engine as engine
 
+_memory_store = TechniqueStore()
+
 
 def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
@@ -229,13 +232,16 @@ def get_phrase_grid(
 
     section = sections[section_index]
 
-    # Collect notes for active tracks
+    # Collect notes for active tracks — use the section's scene_index
+    # (which maps to the actual clip slot), not the section_index
+    # (which is a position in the section graph)
     notes_by_track: dict[int, list] = {}
+    scene_idx = section.scene_index if hasattr(section, "scene_index") else section_index
     for t_idx in section.tracks_active:
         try:
             result = ableton.send_command("get_notes", {
                 "track_index": t_idx,
-                "clip_index": section_index,
+                "clip_index": scene_idx,
             })
             notes_by_track[t_idx] = result.get("notes", [])
         except Exception:
@@ -377,6 +383,10 @@ def get_harmony_field(
     section = sections[section_index]
 
     # Find a track with notes to analyze harmony
+    # Use theory engine functions directly instead of TCP calls to MCP tools
+    from . import _theory_engine as theory_engine
+    from . import _harmony_engine as harmony_engine
+
     scale_info = None
     harmony_analysis = None
     progression_info = None
@@ -384,29 +394,97 @@ def get_harmony_field(
 
     for t_idx in section.tracks_active:
         try:
-            # Try identify_scale
-            si = ableton.send_command("identify_scale", {
-                "track_index": t_idx, "clip_index": section_index
-            })
-            if si.get("top_match"):
-                scale_info = si
-
-            # Try analyze_harmony
-            ha = ableton.send_command("analyze_harmony", {
-                "track_index": t_idx, "clip_index": section_index
+            # Get notes via TCP (valid Remote Script command)
+            result = ableton.send_command("get_notes", {
+                "track_index": t_idx, "clip_index": section_index,
             })
-            if ha.get("chords"):
-                harmony_analysis = ha
-
-                # Classify progression if we have chords
-                chord_names = [c.get("chord_name", "") for c in ha.get("chords", []) if c.get("chord_name")]
-                if len(chord_names) >= 2:
-                    try:
-                        progression_info = ableton.send_command("classify_progression", {
-                            "chords": chord_names[:8]
+            notes = result.get("notes", [])
+            if not notes:
+                continue
+
+            # identify_scale: run key detection directly
+            if not scale_info:
+                detected = theory_engine.detect_key(notes, mode_detection=True)
+                top = {
+                    "key": f"{detected['tonic_name']} {detected['mode'].replace('_', ' ')}",
+                    "confidence": detected["confidence"],
+                    "mode": detected["mode"].replace("_", " "),
+                    "mode_id": detected["mode"],
+                    "tonic": detected["tonic_name"],
+                }
+                scale_info = {"top_match": top}
+
+            # analyze_harmony: chordify + roman numeral analysis directly
+            if not harmony_analysis:
+                key_info = theory_engine.detect_key(notes)
+                tonic = key_info["tonic"]
+                mode = key_info["mode"]
+                chord_groups = theory_engine.chordify(notes)
+                if chord_groups:
+                    chords = []
+                    for group in chord_groups:
+                        pitches = group["pitches"]
+                        pcs = group["pitch_classes"]
+                        rn = theory_engine.roman_numeral(pcs, tonic, mode)
+                        cn = theory_engine.chord_name(pitches)
+                        chords.append({
+                            "beat": group["beat"],
+                            "duration": group["duration"],
+                            "chord_name": cn,
+                            "roman_numeral": rn["figure"],
+                            "figure": rn["figure"],
+                            "quality": rn["quality"],
                         })
-                    except Exception:
-                        pass
+                    if chords:
+                        harmony_analysis = {
+                            "key": f"{key_info['tonic_name']} {mode.replace('_', ' ')}",
+                            "chords": chords,
+                        }
+
+                        # classify_progression directly
+                        chord_names = [c["chord_name"] for c in chords if c.get("chord_name")]
+                        if len(chord_names) >= 2:
+                            try:
+                                parsed = [harmony_engine.parse_chord(c) for c in chord_names[:8]]
+                                transforms = harmony_engine.classify_transform_sequence(parsed)
+                                pattern = "".join(transforms)
+                                classification = "free neo-Riemannian progression"
+                                clean = pattern.replace("?", "")
+                                if len(clean) >= 2:
+                                    pair = clean[:2]
+                                    if pair in ("PL", "LP") and all(c in "PL" for c in clean):
+                                        classification = "hexatonic cycle fragment"
+                                    elif pair in ("PR", "RP") and all(c in "PR" for c in clean):
+                                        classification = "octatonic cycle fragment"
+                                    elif pair in ("LR", "RL") and all(c in "LR" for c in clean):
+                                        classification = "diatonic cycle fragment"
+                                progression_info = {
+                                    "chords": chord_names[:8],
+                                    "transforms": transforms,
+                                    "pattern": pattern,
+                                    "classification": classification,
+                                }
+                            except Exception:
+                                pass
+
+            # Populate voice_leading_info from chord groups
+            if harmony_analysis and not voice_leading_info:
+                try:
+                    chord_groups_vl = theory_engine.chordify(notes)
+                    if len(chord_groups_vl) >= 2:
+                        all_vl_issues = []
+                        for vi in range(1, min(len(chord_groups_vl), 9)):
+                            prev_p = chord_groups_vl[vi - 1]["pitches"]
+                            curr_p = chord_groups_vl[vi]["pitches"]
+                            issues = theory_engine.check_voice_leading(prev_p, curr_p)
+                            all_vl_issues.extend(issues)
+                        voice_leading_info = {
+                            "issues": all_vl_issues,
+                            "issue_count": len(all_vl_issues),
+                            "quality": "clean" if not all_vl_issues else "has_issues",
+                        }
+                except Exception:
+                    pass
 
             if scale_info and harmony_analysis:
                 break
@@ -540,19 +618,23 @@ def get_section_outcomes(
     section_type: filter to a specific type (intro, verse, chorus, etc.)
                   Leave empty for all types.
     """
-    ableton = _get_ableton(ctx)
-
+    # Fetch composition outcomes directly from TechniqueStore
     try:
-        memory_result = ableton.send_command("memory_list", {
-            "type": "composition_outcome",
-            "limit": limit,
-            "sort_by": "updated_at",
-        })
-        techniques = memory_result.get("techniques", [])
+        techniques = _memory_store.list_techniques(
+            type_filter="composition_outcome", sort_by="updated_at", limit=limit,
+        )
     except Exception:
         techniques = []
 
-    outcomes = [t.get("payload", {}) for t in techniques if isinstance(t.get("payload"), dict)]
+    outcomes = []
+    for t in techniques:
+        try:
+            full = _memory_store.get(t["id"])
+            payload = full.get("payload", {})
+            if isinstance(payload, dict):
+                outcomes.append(payload)
+        except Exception:
+            pass
 
     result = engine.analyze_section_outcomes(outcomes)
 

package/mcp_server/tools/devices.py

@@ -145,11 +145,25 @@ def _postflight_loaded_device(ctx: Context, result: dict) -> dict:
     if match is None:
         match = devices[-1]
 
+    # get_track_info returns device summaries without a parameters list,
+    # so use the 'parameter_count' field if present, otherwise fetch
+    # the actual device info for an accurate count.
+    param_count = match.get("parameter_count", len(match.get("parameters", [])))
+    if param_count == 0 and match.get("index") is not None:
+        try:
+            full_info = _get_ableton(ctx).send_command("get_device_info", {
+                "track_index": int(track_index),
+                "device_index": int(match["index"]),
+            })
+            param_count = full_info.get("parameter_count", 0)
+        except Exception:
+            pass
+
     device_info = _annotate_device_info({
         "name": match.get("name"),
         "class_name": match.get("class_name"),
         "is_active": match.get("is_active"),
-        "parameter_count": len(match.get("parameters", [])),
+        "parameter_count": param_count,
     })
 
     merged = dict(annotated)

package/mcp_server/tools/midi_io.py

@@ -62,7 +62,9 @@ def _safe_output_path(directory: Path, filename: str) -> Path:
     if not safe_name:
         raise ValueError(f"Invalid filename: {filename!r}")
     out = (directory / safe_name).resolve()
-    if not str(out).startswith(str(directory.resolve())):
+    # Use os.sep suffix to prevent prefix collisions (e.g., /foo/bar vs /foo/barbaz)
+    parent = str(directory.resolve()) + os.sep
+    if not (str(out) + os.sep).startswith(parent):
         raise ValueError(f"Filename escapes output directory: {filename!r}")
     return out
 

package/mcp_server/tools/research.py

@@ -15,8 +15,11 @@ from typing import Optional
 from fastmcp import Context
 
 from ..server import mcp
+from ..memory.technique_store import TechniqueStore
 from . import _research_engine as research_engine
 
+_memory_store = TechniqueStore()
+
 
 def _get_ableton(ctx: Context):
     return ctx.lifespan_context["ableton"]
@@ -50,37 +53,33 @@ def research_technique(
     # 1. Analyze query to predict relevant devices
     query_info = research_engine.analyze_query(query)
 
-    # 2. Search device atlas for relevant devices
+    # 2. Search device atlas for relevant devices (Fix 2: correct params)
     device_atlas_results = []
     for device_name in query_info.get("likely_devices", [])[:5]:
         try:
-            ref = ableton.send_command("search_browser", {"query": device_name, "category": "instruments"})
+            ref = ableton.send_command("search_browser", {
+                "path": "instruments",
+                "name_filter": device_name,
+            })
             if ref and not ref.get("error"):
                 device_atlas_results.append(ref)
         except Exception:
             pass
 
-    # 3. Search memory for related techniques
+    # 3. Search memory for related techniques (direct TechniqueStore)
     memory_results = []
     try:
-        # Search technique cards
-        mem = ableton.send_command("memory_list", {
-            "type": "technique_card",
-            "limit": 10,
-            "sort_by": "updated_at",
-        })
-        memory_results.extend(mem.get("techniques", []))
+        memory_results.extend(
+            _memory_store.list_techniques(type_filter="technique_card", sort_by="updated_at", limit=10)
+        )
     except Exception:
         pass
 
     try:
-        # Also search research memories
-        mem = ableton.send_command("memory_list", {
-            "type": "research",
-            "limit": 5,
-            "sort_by": "updated_at",
-        })
-        memory_results.extend(mem.get("techniques", []))
+        # "research" is not a valid type in TechniqueStore — search broadly
+        memory_results.extend(
+            _memory_store.search(query=query, limit=5)
+        )
     except Exception:
         pass
 
@@ -131,19 +130,24 @@ def get_emotional_arc(ctx: Context) -> dict:
         }
 
     # Try to build harmony fields for richer analysis
+    # Use theory engine directly instead of TCP call to MCP tool
+    from . import _theory_engine as theory_engine
+
     harmony_fields = []
     for i, section in enumerate(sections):
         hf = engine.HarmonyField(section_id=section.section_id)
-        # Try to get harmony data
+        # Try to get harmony data by fetching notes then running engine
         for t_idx in section.tracks_active[:3]:
             try:
-                si = ableton.send_command("identify_scale", {
+                result = ableton.send_command("get_notes", {
                     "track_index": t_idx, "clip_index": i,
                 })
-                if si.get("top_match"):
-                    hf.key = si["top_match"].get("tonic", "")
-                    hf.mode = si["top_match"].get("mode", "")
-                    hf.confidence = si["top_match"].get("confidence", 0.0)
+                notes = result.get("notes", [])
+                if notes:
+                    detected = theory_engine.detect_key(notes, mode_detection=True)
+                    hf.key = detected.get("tonic_name", "")
+                    hf.mode = detected.get("mode", "")
+                    hf.confidence = detected.get("confidence", 0.0)
                     break
             except Exception:
                 continue
@@ -193,16 +197,12 @@ def get_style_tactics(
     if not artist_or_genre or not artist_or_genre.strip():
         return {"error": "artist_or_genre cannot be empty"}
 
-    ableton = _get_ableton(ctx)
-
-    # Search user memory for saved tactics
+    # Search user memory for saved tactics (direct TechniqueStore)
     memory_tactics = []
     try:
-        mem = ableton.send_command("memory_list", {
-            "type": "style_tactic",
-            "limit": 10,
-        })
-        memory_tactics = mem.get("techniques", [])
+        memory_tactics = _memory_store.search(
+            query=artist_or_genre, limit=10,
+        )
     except Exception:
         pass
 

package/mcp_server/tools/tracks.py

@@ -167,7 +167,7 @@ def stop_track_clips(ctx: Context, track_index: int) -> dict:
 @mcp.tool()
 def set_group_fold(ctx: Context, track_index: int, folded: bool) -> dict:
     """Fold or unfold a group track to show/hide its children."""
-    _validate_track_index(track_index)
+    _validate_track_index(track_index, allow_return=False)
     return _get_ableton(ctx).send_command("set_group_fold", {
         "track_index": track_index,
         "folded": folded,
@@ -176,10 +176,10 @@ def set_group_fold(ctx: Context, track_index: int, folded: bool) -> dict:
 
 @mcp.tool()
 def set_track_input_monitoring(ctx: Context, track_index: int, state: int) -> dict:
-    """Set input monitoring (0=In, 1=Auto, 2=Off). Only for regular tracks, not return tracks."""
+    """Set input monitoring (0=Off, 1=In, 2=Auto). Only for regular tracks, not return tracks."""
     _validate_track_index(track_index)
     if state not in (0, 1, 2):
-        raise ValueError("Monitoring state must be 0=In, 1=Auto, or 2=Off")
+        raise ValueError("Monitoring state must be 0=Off, 1=In, or 2=Auto")
     return _get_ableton(ctx).send_command("set_track_input_monitoring", {
         "track_index": track_index,
         "state": state,

package/mcp_server/translation_engine/tools.py

@@ -16,30 +16,64 @@ from .critics import build_translation_report, run_all_translation_critics
 
 
 def _fetch_translation_data(ctx: Context) -> dict:
-    """Fetch mix snapshot data needed for translation analysis."""
+    """Fetch mix snapshot data needed for translation analysis.
+
+    Builds snapshot from real available data:
+    - Spectrum from SpectralCache (direct access, not TCP)
+    - Stereo width estimated from track pan values
+    - Foreground detection from role inference
+    """
     ableton = ctx.lifespan_context["ableton"]
 
-    # Get mix snapshot — contains spectral and stereo info
-    snapshot = {}
+    # Get spectral data directly from SpectralCache
+    spectrum_bands = {}
     try:
-        snapshot = ableton.send_command("get_mix_snapshot", {})
+        spectral = ctx.lifespan_context.get("spectral")
+        if spectral and spectral.is_connected:
+            spec_data = spectral.get("spectrum")
+            if spec_data and isinstance(spec_data["value"], dict):
+                spectrum_bands = spec_data["value"]
     except Exception:
         pass
 
-    # Extract spectral bands from snapshot
-    spectrum = snapshot.get("spectrum", {})
-    stereo = snapshot.get("stereo", {})
+    # Estimate stereo width from track pans via session info
+    stereo_width = 0.0
+    center_strength = 0.5
+    has_foreground = True
+    foreground_masked = False
+    try:
+        session_info = ableton.send_command("get_session_info", {})
+        tracks = session_info.get("tracks", [])
+        if tracks:
+            # Pan may be at top level or nested under mixer.panning
+            def _get_pan(t: dict) -> float:
+                mixer = t.get("mixer")
+                if isinstance(mixer, dict):
+                    return abs(mixer.get("panning", 0.0))
+                return abs(t.get("pan", 0.0))
+            pan_values = [_get_pan(t) for t in tracks if not t.get("muted", False)]
+            if pan_values:
+                # Wider pans = more stereo width
+                stereo_width = min(1.0, sum(pan_values) / max(len(pan_values), 1))
+                # Center strength = proportion of tracks near center
+                center_count = sum(1 for p in pan_values if p < 0.15)
+                center_strength = center_count / max(len(pan_values), 1)
+
+            # Simple foreground detection: at least one unmuted, non-quiet track
+            has_foreground = any(not t.get("muted", False) for t in tracks)
+    except Exception:
+        pass
 
     return {
-        "stereo_width": stereo.get("side_activity", 0.0),
-        "center_strength": stereo.get("center_strength", 0.5),
-        "sub_energy": spectrum.get("sub", 0.0),
-        "low_energy": spectrum.get("low", 0.0),
-        "low_mid_energy": spectrum.get("low_mid", 0.0),
-        "high_energy": spectrum.get("high", 0.0),
-        "presence_energy": spectrum.get("presence", 0.0),
-        "has_foreground": snapshot.get("has_foreground", True),
-        "foreground_masked": snapshot.get("foreground_masked", False),
+        "stereo_width": stereo_width,
+        "center_strength": center_strength,
+        "sub_energy": spectrum_bands.get("sub", 0.0),
+        "low_energy": spectrum_bands.get("low", 0.0),
+        "low_mid_energy": spectrum_bands.get("low_mid", 0.0),
+        "high_energy": spectrum_bands.get("high", 0.0),
+        "presence_energy": spectrum_bands.get("presence", 0.0),
+        "has_foreground": has_foreground,
+        "foreground_masked": foreground_masked,
     }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.15",
+  "version": "1.9.16",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 236 tools, 32 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",

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.9.14"
+__version__ = "1.9.16"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/remote_script/LivePilot/arrangement.py

@@ -352,6 +352,12 @@ def modify_arrangement_notes(song, params):
             note.velocity = float(mod["velocity"])
         if "probability" in mod:
             note.probability = float(mod["probability"])
+        if "mute" in mod:
+            note.mute = bool(mod["mute"])
+        if "velocity_deviation" in mod:
+            note.velocity_deviation = float(mod["velocity_deviation"])
+        if "release_velocity" in mod:
+            note.release_velocity = float(mod["release_velocity"])
         modified_count += 1
 
     song.begin_undo_step()
@@ -557,7 +563,9 @@ def transpose_arrangement_notes(song, params):
     clip = arr_clips[clip_index]
 
     from_time = float(params.get("from_time", 0.0))
-    time_span = float(params.get("time_span", clip.length))
+    # Default span covers from from_time to end of clip, not the full clip length
+    default_span = max(0.0, clip.length - from_time) if clip.length > 0 else 32768.0
+    time_span = float(params.get("time_span", default_span))
 
     all_notes = clip.get_notes_extended(0, 128, from_time, time_span)