livepilot 1.9.18 → 1.9.19

package/.claude-plugin/marketplace.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
   "name": "dreamrec-LivePilot",
-  "description": "Agentic MCP production system for Ableton Live 12 — 236 tools, 31 domains",
+  "description": "Agentic MCP production system for Ableton Live 12 — 236 tools, 32 domains",
   "owner": {
     "name": "dreamrec",
     "email": "dreamrec@users.noreply.github.com"
@@ -9,8 +9,8 @@
   "plugins": [
     {
       "name": "livepilot",
-      "description": "Agentic production system for Ableton Live 12 — 236 tools, 31 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
-      "version": "1.9.18",
+      "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",
+      "version": "1.9.19",
       "author": {
         "name": "Pilot Studio"
       },

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.9.19 — Theory Engine & Meters Fix Pass (April 2026)
+
+### Bug Fixes
+- **fix(mixing):** `get_track_meters` crashed on tracks with MIDI-only output — now guards `output_meter_*` with `has_audio_output` check
+- **fix(mixing):** `get_mix_snapshot` same crash on MIDI-output tracks — same guard applied
+- **fix(tracks):** `create_midi_track` / `create_audio_track` left newly created tracks armed — now auto-disarms unless `arm=true` param is passed
+- **fix(theory):** `roman_numeral()` failed to recognize 7th chords (Dm7, Gm7, Bbmaj7) — now detects 7th intervals via triad-subset matching with scored best-match selection
+- **fix(theory):** `roman_figure_to_pitches()` produced out-of-key pitches (C#, G#) for jazz figures in minor keys — now uses scale-derived chord quality and scale-derived 7th intervals instead of forcing quality from Roman numeral case
+- **fix(harmony):** `parse_chord()` rejected "minor seventh", "dominant seventh" and other extended chord qualities — now normalizes to base triad for neo-Riemannian analysis
+- **fix(harmony):** `classify_transform_sequence()` only detected single P/L/R transforms — now tries 2-step compound transforms (PL, PR, RL, etc.)
+- **fix(theory):** `roman_numeral()` picked wrong chord when 7th created ambiguity (Bbmaj7 matched as Dm instead of Bb) — scoring prefers highest overlap + root-position bonus
+
 ## 1.9.18 — Deep Audit Fix Pass (April 2026)
 
 ### Critical Fixes

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

@@ -1,7 +1,7 @@
 {
   "name": "livepilot",
-  "version": "1.9.18",
-  "description": "Agentic production system for Ableton Live 12 — 236 tools, 31 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "version": "1.9.19",
+  "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": {
     "name": "Pilot Studio"
   }

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

@@ -1,7 +1,7 @@
 {
   "name": "livepilot",
-  "version": "1.9.18",
-  "description": "Agentic production system for Ableton Live 12 — 236 tools, 31 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "version": "1.9.19",
+  "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": {
     "name": "Pilot Studio"
   }

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

@@ -1,11 +1,11 @@
 ---
 name: livepilot-core
-description: Core discipline for LivePilot — agentic production system for Ableton Live 12. 236 tools across 31 domains. This skill should be used whenever working with Ableton Live through MCP tools. Provides golden rules, tool speed tiers, error handling protocol, and pointers to domain and engine skills.
+description: Core discipline for LivePilot — agentic production system for Ableton Live 12. 236 tools across 32 domains. This skill should be used whenever working with Ableton Live through MCP tools. Provides golden rules, tool speed tiers, error handling protocol, and pointers to domain and engine skills.
 ---
 
 # LivePilot Core — Ableton Live 12
 
-Agentic production system for Ableton Live 12. 236 tools across 31 domains, three layers:
+Agentic production system for Ableton Live 12. 236 tools across 32 domains, three layers:
 
 - **Device Atlas** — 280+ instruments, 139 drum kits, 350+ impulse responses. Consult `references/device-atlas/` before loading any device. Never guess a device name.
 - **M4L Analyzer** — Real-time audio analysis on the master bus (8-band spectrum, RMS/peak, key detection). Optional — all core tools work without it.

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

@@ -1,6 +1,6 @@
-# LivePilot v1.9.18 — Architecture & Tool Reference
+# LivePilot v1.9.19 — Architecture & Tool Reference
 
-Agentic production system for Ableton Live 12. 236 tools across 31 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), 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.
+Agentic production system for Ableton Live 12. 236 tools across 32 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), 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.
 
 ## Architecture
 

package/m4l_device/livepilot_bridge.js

@@ -84,7 +84,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.9.18"});
+            send_response({"ok": true, "version": "1.9.19"});
             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.9.18"
+__version__ = "1.9.19"

package/mcp_server/tools/_harmony_engine.py

@@ -29,8 +29,26 @@ def chord_to_str(root_pc: int, quality: str) -> str:
 def parse_chord(chord_str: str) -> tuple[int, str]:
     """Parse 'C major' → (0, 'major'), 'F# minor' → (6, 'minor').
 
-    Uses _theory_engine.parse_key() internally — check what it returns!
+    Also handles 7th chord qualities by reducing to base triad:
+    'D minor seventh' → (2, 'minor'), 'G dominant seventh' → (7, 'major').
+    Neo-Riemannian transforms operate on triads, so we strip extensions.
     """
+    # Normalize extended chord quality names to base triad
+    s = chord_str.strip()
+    _QUALITY_MAP = {
+        "minor seventh": "minor", "minor 7th": "minor", "minor7": "minor",
+        "major seventh": "major", "major 7th": "major", "major7": "major",
+        "dominant seventh": "major", "dominant 7th": "major", "dominant7": "major",
+        "diminished seventh": "minor", "diminished 7th": "minor",
+        "half-diminished seventh": "minor", "half-diminished": "minor",
+    }
+    for ext, base in _QUALITY_MAP.items():
+        if ext in s.lower():
+            # Extract root (everything before the quality)
+            idx = s.lower().index(ext)
+            root = s[:idx].strip() or s.split()[0]
+            return (engine.parse_key(f"{root} {base}")["tonic"], base)
+
     parsed = engine.parse_key(chord_str)
     mode = parsed["mode"]
     if mode not in ("major", "minor"):
@@ -177,14 +195,30 @@ def find_shortest_path(
 # ---------------------------------------------------------------------------
 
 def classify_transform_sequence(chords: list[tuple[int, str]]) -> list[str]:
-    """Identify the PRL transform between each consecutive pair of chords."""
+    """Identify the PRL transform between each consecutive pair of chords.
+
+    Tries single transforms (P, L, R) first, then 2-step compound
+    transforms (PL, PR, LP, LR, RP, RL) for richer classification.
+    """
+    _COMPOUNDS = ["PL", "PR", "LP", "LR", "RP", "RL",
+                  "PP", "LL", "RR"]
     result = []
     for i in range(len(chords) - 1):
         found = "?"
+        # Try single transforms first
         for label, fn in TRANSFORMS.items():
             if fn(*chords[i]) == chords[i + 1]:
                 found = label
                 break
+        # Try 2-step compound transforms
+        if found == "?":
+            for compound in _COMPOUNDS:
+                try:
+                    if apply_transforms(*chords[i], compound) == chords[i + 1]:
+                        found = compound
+                        break
+                except (ValueError, KeyError):
+                    continue
         result.append(found)
     return result
 

package/mcp_server/tools/_theory_engine.py

@@ -231,33 +231,73 @@ def chord_name(midi_pitches: list[int]) -> str:
 
 
 def roman_numeral(chord_pcs: list[int], tonic: int, mode: str) -> dict:
-    """Match chord pitch classes -> Roman numeral figure."""
+    """Match chord pitch classes -> Roman numeral figure.
+
+    Recognizes triads and 7th chords by checking if the input contains
+    a scale-degree triad, then detecting the 7th (if any).
+    """
     pcs_set = set(pc % 12 for pc in chord_pcs)
     bass_pc = chord_pcs[0] % 12 if chord_pcs else 0
 
     best = {"figure": "?", "quality": "unknown", "degree": 0,
             "inversion": 0, "root_name": NOTE_NAMES[tonic]}
+    best_score = -1
 
     for degree in range(7):
         triad = build_chord(degree, tonic, mode)
         triad_set = set(triad["pitch_classes"])
-        if pcs_set == triad_set or pcs_set.issubset(triad_set):
-            quality = triad["quality"]
-            label = ROMAN_LABELS[degree]
-            if quality in ("minor", "diminished"):
-                label = label.lower()
-            if quality == "diminished":
-                label += "\u00b0"
-            # Detect inversion
-            inv = 0
-            if bass_pc != triad["root_pc"]:
-                if bass_pc == triad["pitch_classes"][1]:
-                    inv = 1
-                elif bass_pc == triad["pitch_classes"][2]:
-                    inv = 2
-            best = {"figure": label, "quality": quality, "degree": degree,
-                    "inversion": inv, "root_name": triad["root_name"]}
-            break
+        # Match: exact triad, triad is subset of input (7th chord),
+        # or input is subset of triad (power chord / omitted note)
+        if not (pcs_set == triad_set or triad_set.issubset(pcs_set)
+                or pcs_set.issubset(triad_set)):
+            continue
+
+        # Score: prefer matches with more overlap and bass-note match
+        overlap = len(pcs_set & triad_set)
+        score = overlap * 10
+        if bass_pc == triad["root_pc"]:
+            score += 5  # root position bonus
+
+        if score <= best_score:
+            continue
+
+        quality = triad["quality"]
+        label = ROMAN_LABELS[degree]
+        if quality in ("minor", "diminished"):
+            label = label.lower()
+        if quality == "diminished":
+            label += "\u00b0"
+
+        # Detect 7th: extra pitch class beyond the triad
+        extra_pcs = pcs_set - triad_set
+        if extra_pcs:
+            seventh_interval = (list(extra_pcs)[0] - triad["root_pc"]) % 12
+            if seventh_interval == 10:  # minor/dominant 7th
+                label += "7"
+                if quality == "diminished":
+                    quality = "half-diminished seventh"
+                elif quality == "minor":
+                    quality = "minor seventh"
+                else:
+                    quality = "dominant seventh"
+            elif seventh_interval == 11:  # major 7th
+                label += "maj7"
+                quality = "major seventh"
+            elif seventh_interval == 9:  # diminished 7th
+                label += "o7"
+                quality = "diminished seventh"
+
+        # Detect inversion
+        inv = 0
+        if bass_pc != triad["root_pc"]:
+            if bass_pc == triad["pitch_classes"][1]:
+                inv = 1
+            elif bass_pc == triad["pitch_classes"][2]:
+                inv = 2
+
+        best = {"figure": label, "quality": quality, "degree": degree,
+                "inversion": inv, "root_name": triad["root_name"]}
+        best_score = score
 
     return best
 
@@ -302,31 +342,48 @@ def roman_figure_to_pitches(figure: str, tonic: int, mode: str) -> dict:
     chord = build_chord(degree, tonic, mode)
     root_pc = (chord["root_pc"] + chromatic_shift) % 12
 
-    # Build pitch classes based on quality
-    if is_minor_quality:
-        pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 7) % 12]
+    # Build pitch classes based on quality.
+    # When there's no chromatic alteration, use scale-derived quality so
+    # that e.g. "vi7" in D minor correctly yields Bb major 7th, not Bb minor.
+    # Only force minor from case when there's an explicit accidental.
+    if chromatic_shift != 0 and is_minor_quality:
         quality = "minor"
+    elif chromatic_shift != 0 and not is_minor_quality:
+        quality = "major"
     else:
-        # Use scale-derived quality
         quality = chord["quality"]
-        if quality == "minor":
-            pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 7) % 12]
-        elif quality == "diminished":
-            pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 6) % 12]
-        elif quality == "augmented":
-            pcs = [root_pc, (root_pc + 4) % 12, (root_pc + 8) % 12]
-        else:
-            pcs = [root_pc, (root_pc + 4) % 12, (root_pc + 7) % 12]
 
-    # Handle suffix
+    if quality == "minor":
+        pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 7) % 12]
+    elif quality == "diminished":
+        pcs = [root_pc, (root_pc + 3) % 12, (root_pc + 6) % 12]
+    elif quality == "augmented":
+        pcs = [root_pc, (root_pc + 4) % 12, (root_pc + 8) % 12]
+    else:
+        pcs = [root_pc, (root_pc + 4) % 12, (root_pc + 7) % 12]
+
+    # Handle suffix — derive 7th from the scale when possible
     suffix = remaining.lower()
     if suffix == "7":
-        seventh = (root_pc + 10) % 12  # dominant/minor 7th
+        # Use scale-derived 7th: pitch class a diatonic 7th above the root
+        scale = get_scale_pitches(tonic, mode)
+        seventh_degree = (degree + 6) % 7  # 7th of the chord = 6 steps up
+        seventh = scale[seventh_degree]
+        seventh_interval = (seventh - root_pc) % 12
         pcs.append(seventh)
-        if quality == "minor":
-            quality = "minor seventh"
+        if seventh_interval == 11:
+            quality = "major seventh"
+        elif seventh_interval == 10:
+            if quality == "diminished":
+                quality = "half-diminished seventh"
+            elif quality == "minor":
+                quality = "minor seventh"
+            else:
+                quality = "dominant seventh"
+        elif seventh_interval == 9:
+            quality = "diminished seventh"
         else:
-            quality = "dominant seventh"
+            quality = "minor seventh" if quality == "minor" else "dominant seventh"
     elif suffix == "o7":
         seventh = (root_pc + 9) % 12  # diminished 7th
         pcs.append(seventh)

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.9.18",
+  "version": "1.9.19",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 236 tools, 31 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "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",
   "license": "MIT",
   "type": "commonjs",

package/remote_script/LivePilot/__init__.py

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

package/remote_script/LivePilot/mixing.py

@@ -132,11 +132,18 @@ def get_track_meters(song, params):
         entry = {
             "index": idx,
             "name": track.name,
-            "level": track.output_meter_level,
         }
-        if include_stereo:
-            entry["left"] = track.output_meter_left
-            entry["right"] = track.output_meter_right
+        if track.has_audio_output:
+            entry["level"] = track.output_meter_level
+            if include_stereo:
+                entry["left"] = track.output_meter_left
+                entry["right"] = track.output_meter_right
+        else:
+            entry["level"] = 0.0
+            entry["has_audio_output"] = False
+            if include_stereo:
+                entry["left"] = 0.0
+                entry["right"] = 0.0
         return entry
 
     if track_index is not None:
@@ -170,7 +177,7 @@ def get_mix_snapshot(song, params):
         tracks.append({
             "index": i,
             "name": track.name,
-            "meter_level": track.output_meter_level,
+            "meter_level": track.output_meter_level if track.has_audio_output else 0.0,
             "volume": track.mixer_device.volume.value,
             "pan": track.mixer_device.panning.value,
             "mute": track.mute,

package/remote_script/LivePilot/tracks.py

@@ -122,6 +122,9 @@ def create_midi_track(song, params):
         track.name = str(params["name"])
     if "color_index" in params:
         track.color_index = int(params["color_index"])
+    # Ableton auto-arms newly created tracks — disarm to avoid surprises
+    if track.arm and not params.get("arm", False):
+        track.arm = False
     return {"index": new_index, "name": track.name}
 
 
@@ -139,6 +142,9 @@ def create_audio_track(song, params):
         track.name = str(params["name"])
     if "color_index" in params:
         track.color_index = int(params["color_index"])
+    # Ableton auto-arms newly created tracks — disarm to avoid surprises
+    if track.arm and not params.get("arm", False):
+        track.arm = False
     return {"index": new_index, "name": track.name}