livepilot 1.9.17 → 1.9.19

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "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",
-      "version": "1.9.17",
+      "version": "1.9.19",
       "author": {
         "name": "Pilot Studio"
       },

package/AGENTS.md

@@ -1,4 +1,4 @@
-# LivePilot v1.9.17 — Ableton Live 12
+# LivePilot v1.9.18 — Ableton Live 12
 
 ## Project
 - **Repo:** This directory (LivePilot)
@@ -22,7 +22,7 @@
 ## Key Rules
 - ALL Live Object Model (LOM) calls must execute on Ableton's main thread via schedule_message queue
 - Live 12 minimum — use modern note API (add_new_notes, get_notes_extended, apply_note_modifications)
-- 236 tools across 32 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception, agent_os, composition, motif, research, planner, project_brain, runtime, evaluation, memory_fabric, mix_engine, sound_design, transition_engine, reference_engine, translation_engine, performance_engine
+- 236 tools across 31 domains: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception, agent_os, composition, motif, research, planner, project_brain, runtime, evaluation, mix_engine, sound_design, transition_engine, reference_engine, translation_engine, performance_engine
 - JSON over TCP, newline-delimited, port 9878
 - Structured errors with codes: INDEX_ERROR, NOT_FOUND, INVALID_PARAM, STATE_ERROR, TIMEOUT, INTERNAL
 

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # 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
+- **fix(tracks):** monitoring enum mismatch — MCP advertised `0=Off,1=In,2=Auto` but Remote Script uses `0=In,1=Auto,2=Off`; clients deterministically chose wrong mode
+- **fix(connection):** retry logic could replay mutating commands after `sendall` succeeded — added `_send_completed` flag to prevent double mutations
+- **fix(m4l_bridge):** `capture_stop` cancelled in-flight capture future instead of resolving it — callers got `CancelledError` instead of partial result
+
+### Medium Fixes
+- **fix(skills):** removed 6 phantom tool names from speed tiers (`analyze_dynamic_range`, `analyze_spectral_evolution`, `separate_stems`, `diagnose_mix`, `transcribe_to_midi`, `compare_loudness`)
+- **fix(clip_automation):** added `int()` casts to `send_index`, `device_index`, `parameter_index` — prevented TypeError when MCP sends strings
+- **fix(arrangement):** `add_arrangement_notes` now supports `probability`, `velocity_deviation`, `release_velocity` (parity with session `add_notes`)
+- **fix(devices/browser):** reset `_iterations` counter per category in URI search — prevented premature cutoff for devices in later categories
+- **fix(imports):** standardized 6 engine files from `mcp.server.fastmcp` to `fastmcp` import path
+- **fix(docs):** corrected domain count from 32 to 31 (`memory_fabric` is an alias for `memory`) across 17 files
+- **fix(server.json):** added missing `, MIDI I/O` to description to match package.json
+
+### Low Fixes
+- **fix(clips):** `delete_clip` now checks `has_clip` before deleting
+- **fix(arrangement):** `back_to_arranger` no longer reads write-only trigger property
+- **fix(utils):** return track error message no longer shows `(0..-1)` when none exist
+- **fix(connection):** removed dead `send_command_async` and unused `asyncio` import
+
 ## 1.9.17 — Skills Architecture V2 (April 2026)
 
 ### Skills (9 new, 1 slimmed)
@@ -106,7 +140,7 @@
 - Fix(Med): Ledger key mismatch — memory promotion now reads correct 'action_ledger' key
 
 ### Stats
-- 236 tools across 32 domains (was 194)
+- 236 tools across 31 domains (was 194)
 - 1,014 tests passing (was ~400)
 - 12 new engine packages
 - 36 new MCP tools

package/README.md

@@ -50,7 +50,7 @@
 │                             ▼                               │
 │                    ┌─────────────────┐                      │
 │                    │   236 MCP Tools  │                      │
-│                    │   32 domains     │                      │
+│                    │   31 domains     │                      │
 │                    └────────┬────────┘                      │
 │                             │                               │
 │             Remote Script ──┤── TCP 9878                    │
@@ -79,7 +79,7 @@ All three feed into 236 deterministic tools that execute on Ableton's main threa
 
 ## Tools
 
-236 tools across 32 domains. Highlights below — [full catalog here](docs/manual/tool-catalog.md).
+236 tools across 31 domains. Highlights below — [full catalog here](docs/manual/tool-catalog.md).
 
 <br>
 

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

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.17",
+  "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,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.17",
+  "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

@@ -34,20 +34,16 @@ Agentic production system for Ableton Live 12. 236 tools across 32 domains, thre
 All 236 core tools plus M4L perception tools.
 
 ### Fast (1-5s) — Use freely
-`analyze_loudness` · `analyze_dynamic_range` · `compare_loudness`
+`analyze_loudness` · `analyze_mix` · `analyze_sound_design`
 
 ### Slow (5-15s) — Tell the user first
-`analyze_spectral_evolution` · `compare_to_reference` · `transcribe_to_midi`
-
-### Heavy (30-120s) — ALWAYS ask first
-`separate_stems` · `diagnose_mix` — GPU-intensive. Never call speculatively.
+`compare_to_reference` · `analyze_spectrum_offline` · `read_audio_metadata`
 
 **Escalation pattern:** Start fast, escalate only with consent:
 ```
 Level 1 (instant):  get_master_spectrum + get_track_meters
-Level 2 (fast):     analyze_loudness + analyze_dynamic_range
-Level 3 (slow):     analyze_spectral_evolution + compare_to_reference
-Level 4 (heavy):    separate_stems → diagnose_mix
+Level 2 (fast):     analyze_loudness + analyze_mix
+Level 3 (slow):     compare_to_reference + analyze_spectrum_offline
 ```
 
 ## Error Handling Protocol

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

@@ -1,4 +1,4 @@
-# LivePilot v1.9.17 — Architecture & Tool Reference
+# LivePilot v1.9.19 — Architecture & Tool Reference
 
 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.
 

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

@@ -104,7 +104,7 @@ Call `get_capability_state` at the start of any evaluation session. The response
 {
   "mode": "normal",
   "analyzer_connected": true,
-  "bridge_version": "1.9.17",
+  "bridge_version": "1.9.18",
   "spectral_cache_age_ms": 1200,
   "flucoma_available": false,
   "session_connected": true

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

@@ -145,9 +145,8 @@ Use the mix engine when the user wants a critical evaluation of their mix, not j
 Follow this progression — start fast, go deeper only when needed:
 
 1. **Instant:** `get_master_spectrum` + `get_track_meters` — frequency balance + levels. Answers 80% of mix questions.
-2. **Fast (1-5s):** `analyze_loudness` + `analyze_dynamic_range` — LUFS, true peak, LRA, crest factor. For mastering prep.
-3. **Slow (5-15s):** `analyze_spectral_evolution` + `compare_to_reference` — timbral trends, reference matching. Ask the user first.
-4. **Heavy (30-120s):** `separate_stems` + `diagnose_mix` — full diagnostic. Requires explicit user consent.
+2. **Fast (1-5s):** `analyze_loudness` + `analyze_mix` — LUFS, true peak, and full mix analysis. For mastering prep.
+3. **Slow (5-15s):** `compare_to_reference` + `analyze_spectrum_offline` — reference matching, offline spectral analysis. Ask the user first.
 
 Never skip levels. Start at the lowest appropriate level and offer to go deeper.
 

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

@@ -28,21 +28,21 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 
 ## 2. Tool Count (must ALL match)
 
-Current: **236 tools across 32 domains**.
+Current: **236 tools across 31 domains**.
 Core (no M4L): **149**. Analyzer (M4L): **29**. Perception (offline): **4**.
 
 Verify: `grep -rc "@mcp.tool" mcp_server/tools/ | grep -v ":0" | awk -F: '{sum+=$2} END{print sum}'`
 
 Files that reference tool count:
 - [ ] `README.md` — header, PERCEPTION section ("207 core...29 analyzer"), Analyzer table header "(29)", Perception table header "(4)"
-- [ ] `package.json` → `"description"` (236 tools, 32 domains)
+- [ ] `package.json` → `"description"` (236 tools, 31 domains)
 - [ ] `server.json` → `"description"`
 - [ ] `livepilot/.Codex-plugin/plugin.json` → `"description"` (primary Codex manifest)
 - [ ] `livepilot/.claude-plugin/plugin.json` → `"description"` (must match Codex plugin)
 - [ ] `.claude-plugin/marketplace.json` → `"description"`
-- [ ] `CLAUDE.md` → "236 tools across 32 domains"
-- [ ] `livepilot/skills/livepilot-core/SKILL.md` — "236 tools across 32 domains", Analyzer (29), Perception (4)
-- [ ] `livepilot/skills/livepilot-core/references/overview.md` — "236 tools across 32 domains"
+- [ ] `CLAUDE.md` → "236 tools across 31 domains"
+- [ ] `livepilot/skills/livepilot-core/SKILL.md` — "236 tools across 31 domains", Analyzer (29), Perception (4)
+- [ ] `livepilot/skills/livepilot-core/references/overview.md` — "236 tools across 31 domains"
 - [ ] `docs/manual/index.md` — domain table: Analyzer (29), Perception (4)
 - [ ] `docs/manual/getting-started.md` — "207 core tools...29 analyzer"
 - [ ] `docs/manual/tool-reference.md` — all domains present with correct counts
@@ -56,10 +56,10 @@ Files that reference tool count:
 
 ## 3. Domain Count
 
-Current: **32 domains**: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception, agent_os, composition, research, planner, project_brain, runtime, evaluation, memory_fabric, mix_engine, sound_design, transition_engine, reference_engine, translation_engine, performance_engine.
+Current: **31 domains**: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception, agent_os, composition, motif, research, planner, project_brain, runtime, evaluation, mix_engine, sound_design, transition_engine, reference_engine, translation_engine, performance_engine.
 
-- [ ] All files that mention domain count say "32 domains"
-- [ ] Domain lists include ALL 32 (especially newer domains — they're the most often omitted)
+- [ ] All files that mention domain count say "31 domains"
+- [ ] Domain lists include ALL 31 (especially newer domains — they're the most often omitted)
 
 ## 4. npm Registry
 
@@ -89,8 +89,8 @@ Current: **32 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 
 - [ ] `README.md` — features match current capabilities, "Coming" section is accurate
 - [ ] `docs/manual/getting-started.md` — install instructions current
-- [ ] `docs/manual/tool-reference.md` — all 32 domains listed, all 236 tools present
-- [ ] `docs/TOOL_REFERENCE.md` — all 32 domains present
+- [ ] `docs/manual/tool-reference.md` — all 31 domains listed, all 236 tools present
+- [ ] `docs/TOOL_REFERENCE.md` — all 31 domains present
 - [ ] `docs/M4L_BRIDGE.md` — architecture accurate, core tool count correct
 
 ## 9. Derived Artifacts

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.17"});
+            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.17"
+__version__ = "1.9.19"

package/mcp_server/connection.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import json
 import os
 import socket
@@ -162,15 +161,20 @@ class AbletonConnection:
             try:
                 response = self._send_raw(command)
             except AbletonConnectionError as exc:
-                # Don't retry timeouts — Ableton may have processed the command
+                # If the send phase succeeded (data left this process),
+                # Ableton may have already applied the command.  Never
+                # replay — the duplicate mutation is worse than the error.
+                if getattr(exc, '_send_completed', False):
+                    raise
+                # Don't retry timeouts either
                 if "Timeout" in str(exc):
                     raise
-                # Retry once with a fresh connection for non-timeout errors
+                # Send itself failed — safe to retry with a fresh connection
                 self.disconnect()
                 self.connect()
                 response = self._send_raw(command)
             except OSError:
-                # Retry once with a fresh connection
+                # Socket error before send — safe to retry
                 self.disconnect()
                 self.connect()
                 response = self._send_raw(command)
@@ -196,15 +200,6 @@ class AbletonConnection:
         self._command_log.append(log_entry)
         return response.get("result", {})
 
-    async def send_command_async(self, command_type: str, params: Optional[dict] = None) -> dict:
-        """Async wrapper around send_command that avoids blocking the event loop.
-
-        Runs the blocking TCP send/receive in a thread pool executor so the
-        asyncio event loop remains responsive to other concurrent MCP tools.
-        """
-        loop = asyncio.get_running_loop()
-        return await loop.run_in_executor(None, self.send_command, command_type, params)
-
     # ------------------------------------------------------------------
     # Command log
     # ------------------------------------------------------------------
@@ -234,7 +229,9 @@ class AbletonConnection:
             self.disconnect()
             raise AbletonConnectionError(f"Failed to send command: {exc}") from exc
 
-        # Read until newline, preserving any trailing bytes in _recv_buf
+        # Read until newline, preserving any trailing bytes in _recv_buf.
+        # Any error past this point means the send already reached Ableton,
+        # so callers must NOT retry the command (it may have been applied).
         buf = self._recv_buf
         try:
             while b"\n" not in buf:
@@ -242,31 +239,41 @@ class AbletonConnection:
                 if not chunk:
                     self._recv_buf = b""
                     self.disconnect()
-                    raise AbletonConnectionError("Connection closed by Ableton")
+                    err = AbletonConnectionError("Connection closed by Ableton")
+                    err._send_completed = True
+                    raise err
                 buf += chunk
                 if len(buf) > 10 * 1024 * 1024:  # 10 MB
                     self._recv_buf = b""
                     self.disconnect()
-                    raise AbletonConnectionError("Response too large (>10 MB)")
+                    err = AbletonConnectionError("Response too large (>10 MB)")
+                    err._send_completed = True
+                    raise err
         except socket.timeout as exc:
             self._recv_buf = buf
             self.disconnect()
             other_client = _identify_other_tcp_client(self.host, self.port)
             if other_client:
-                raise AbletonConnectionError(
+                err = AbletonConnectionError(
                     "Timeout waiting for response from Ableton. "
                     f"Another LivePilot client appears to be connected on {self.host}:{self.port} "
                     f"({other_client}). Disconnect the other client and retry."
-                ) from exc
-            raise AbletonConnectionError(
+                )
+                err._send_completed = True
+                raise err from exc
+            err = AbletonConnectionError(
                 f"Timeout waiting for response from Ableton ({RECV_TIMEOUT}s)"
-            ) from exc
+            )
+            err._send_completed = True
+            raise err from exc
         except OSError as exc:
             self._recv_buf = b""
             self.disconnect()
-            raise AbletonConnectionError(
+            err = AbletonConnectionError(
                 f"Socket error reading response: {exc}"
-            ) from exc
+            )
+            err._send_completed = True
+            raise err from exc
 
         line, remainder = buf.split(b"\n", 1)
         self._recv_buf = remainder

package/mcp_server/evaluation/tools.py

@@ -6,7 +6,7 @@ to the appropriate engine-specific evaluator via fabric.evaluate().
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from ..tools._evaluation_contracts import EvaluationRequest, EvaluationResult

package/mcp_server/m4l_bridge.py

@@ -400,15 +400,18 @@ class M4LBridge:
                 return {"error": "M4L capture timeout — device may be busy or removed"}
 
     async def cancel_capture_future(self) -> None:
-        """Cancel any in-progress capture future (called by capture_stop).
+        """Resolve any in-progress capture future with a stopped result.
 
         Does NOT acquire _cmd_lock — send_capture holds it during recording.
-        Cancelling the future causes send_capture's wait_for to raise
-        CancelledError, which releases the lock naturally.
+        Resolving (not cancelling) the future lets send_capture return a
+        clean partial-result dict instead of raising CancelledError.
         """
         if self.receiver and self.receiver._capture_future \
                 and not self.receiver._capture_future.done():
-            self.receiver._capture_future.cancel()
+            self.receiver._capture_future.set_result({
+                "ok": True,
+                "stopped_early": True,
+            })
             self.receiver._capture_future = None
 
     def _build_osc(self, address: str, args: tuple) -> bytes:

package/mcp_server/mix_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from ..tools._evaluation_contracts import EvaluationRequest

package/mcp_server/performance_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from .models import EnergyWindow, SceneRole

package/mcp_server/reference_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from ..tools._research_engine import get_style_tactics

package/mcp_server/sound_design/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation modules.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from .models import (

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/mcp_server/tools/analyzer.py

@@ -634,14 +634,15 @@ async def capture_audio(
 async def capture_stop(ctx: Context) -> dict:
     """Stop an in-progress audio capture early.
 
-    Cancels the running buffer~ recording and returns whatever audio has
-    been captured so far. The partial file is still written to disk.
+    Tells the M4L bridge to stop buffer~ recording and resolves the
+    in-flight capture_audio call with a partial result (stopped_early=True).
+    The partial file is still written to disk by the bridge.
     Requires LivePilot Analyzer on master track.
     """
     cache = _get_spectral(ctx)
     _require_analyzer(cache)
     bridge = _get_m4l(ctx)
-    # Cancel the capture future so send_capture doesn't hang forever
+    # Resolve the capture future so send_capture returns cleanly
     await bridge.cancel_capture_future()
     return await bridge.send_command("capture_stop")
 

package/mcp_server/tools/tracks.py

@@ -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=Off, 1=In, 2=Auto). Only for regular tracks, not return tracks."""
-    _validate_track_index(track_index)
+    """Set input monitoring (0=In, 1=Auto, 2=Off). Only for regular tracks, not return tracks."""
+    _validate_track_index(track_index, allow_return=False)
     if state not in (0, 1, 2):
-        raise ValueError("Monitoring state must be 0=Off, 1=In, or 2=Auto")
+        raise ValueError("Monitoring state must be 0=In, 1=Auto, or 2=Off")
     return _get_ableton(ctx).send_command("set_track_input_monitoring", {
         "track_index": track_index,
         "state": state,

package/mcp_server/translation_engine/tools.py

@@ -6,7 +6,7 @@ then delegates to pure-computation critics.
 
 from __future__ import annotations
 
-from mcp.server.fastmcp import Context
+from fastmcp import Context
 
 from ..server import mcp
 from .critics import build_translation_report, run_all_translation_critics

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.17",
+  "version": "1.9.19",
   "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.17"
+__version__ = "1.9.19"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/remote_script/LivePilot/arrangement.py

@@ -190,13 +190,20 @@ def add_arrangement_notes(song, params):
     try:
         note_specs = []
         for note in notes:
-            spec = Live.Clip.MidiNoteSpecification(
+            kwargs = dict(
                 pitch=int(note["pitch"]),
                 start_time=float(note["start_time"]),
                 duration=float(note["duration"]),
                 velocity=float(note.get("velocity", 100)),
                 mute=bool(note.get("mute", False)),
             )
+            if "probability" in note:
+                kwargs["probability"] = float(note["probability"])
+            if "velocity_deviation" in note:
+                kwargs["velocity_deviation"] = float(note["velocity_deviation"])
+            if "release_velocity" in note:
+                kwargs["release_velocity"] = float(note["release_velocity"])
+            spec = Live.Clip.MidiNoteSpecification(**kwargs)
             note_specs.append(spec)
         clip.add_new_notes(tuple(note_specs))
     finally:
@@ -703,4 +710,4 @@ def toggle_cue_point(song, params):
 def back_to_arranger(song, params):
     """Switch playback from session clips back to the arrangement timeline."""
     song.back_to_arranger = True
-    return {"back_to_arranger": song.back_to_arranger}
+    return {"back_to_arranger": True}

package/remote_script/LivePilot/browser.py

@@ -263,6 +263,7 @@ def load_browser_item(song, params):
         return None
 
     for category in categories:
+        _iterations[0] = 0  # Reset counter per category to avoid premature cutoff
         found = find_by_uri(category, uri)
         if found is not None:
             song.view.selected_track = track

package/remote_script/LivePilot/clip_automation.py

@@ -100,6 +100,7 @@ def set_clip_automation(song, params):
     elif parameter_type == "send":
         if send_index is None:
             raise ValueError("send_index required for send automation")
+        send_index = int(send_index)
         sends = list(track.mixer_device.sends)
         if send_index < 0 or send_index >= len(sends):
             raise IndexError("send_index %d out of range" % send_index)
@@ -107,6 +108,8 @@ def set_clip_automation(song, params):
     elif parameter_type == "device":
         if device_index is None or parameter_index is None:
             raise ValueError("device_index and parameter_index required")
+        device_index = int(device_index)
+        parameter_index = int(parameter_index)
         devices = list(track.devices)
         if device_index < 0 or device_index >= len(devices):
             raise IndexError("device_index %d out of range" % device_index)
@@ -180,6 +183,7 @@ def clear_clip_automation(song, params):
             send_index = params.get("send_index")
             if send_index is None:
                 raise ValueError("send_index required for send automation")
+            send_index = int(send_index)
             sends = list(track.mixer_device.sends)
             if send_index < 0 or send_index >= len(sends):
                 raise IndexError("send_index %d out of range" % send_index)
@@ -189,6 +193,8 @@ def clear_clip_automation(song, params):
             parameter_index = params.get("parameter_index")
             if device_index is None or parameter_index is None:
                 raise ValueError("device_index and parameter_index required")
+            device_index = int(device_index)
+            parameter_index = int(parameter_index)
             devices = list(track.devices)
             if device_index < 0 or device_index >= len(devices):
                 raise IndexError("device_index %d out of range" % device_index)

package/remote_script/LivePilot/clips.py

@@ -72,6 +72,8 @@ def delete_clip(song, params):
     track_index = int(params["track_index"])
     clip_index = int(params["clip_index"])
     clip_slot = get_clip_slot(song, track_index, clip_index)
+    if not clip_slot.has_clip:
+        raise ValueError("No clip in slot %d on track %d" % (clip_index, track_index))
     clip_slot.delete_clip()
     return {"track_index": track_index, "clip_index": clip_index, "deleted": True}
 

package/remote_script/LivePilot/devices.py

@@ -270,6 +270,7 @@ def load_device_by_uri(song, params):
         return None
 
     for category in categories:
+        _iterations[0] = 0  # Reset counter per category to avoid premature cutoff
         found = find_by_uri(category, uri)
         if found is not None:
             song.view.selected_track = track

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}
 
 

package/remote_script/LivePilot/utils.py

@@ -54,8 +54,8 @@ def get_track(song, track_index):
         ri = abs(track_index) - 1
         if ri >= len(return_tracks):
             raise IndexError(
-                "Return track index %d out of range (0..%d)"
-                % (ri, len(return_tracks) - 1)
+                "Return track index %d out of range — %d return tracks available"
+                % (ri, len(return_tracks))
             )
         return return_tracks[ri]
     if track_index >= len(tracks):