livepilot 1.10.6 → 1.10.8

package/mcp_server/tools/theory.py

@@ -245,7 +245,15 @@ def suggest_next_chord(
                 candidates = style_map[k]
                 break
     if not candidates:
-        candidates = style_map.get("I", ["IV", "V"])
+        # BUG-B23: the old fallback hard-coded ["IV", "V"] — uppercase
+        # literals that lie about chord quality in a minor key (where
+        # both iv and v are minor triads). Pick the tonic key ("i" in
+        # minor, "I" in major) and let the style_map's own conventions
+        # populate a minor-appropriate default when available.
+        tonic_key = "i" if is_minor else "I"
+        candidates = style_map.get(tonic_key)
+        if not candidates:
+            candidates = ["iv", "v"] if is_minor else ["IV", "V"]
 
     # Build concrete suggestions with MIDI pitches
     suggestions = []
@@ -450,11 +458,24 @@ def harmonize_melody(
 ) -> dict:
     """Generate a multi-voice harmonization of a melody from a MIDI clip.
 
-    Finds diatonic chords containing each melody note and voices them
-    following basic voice leading rules (smooth bass motion, no crossing).
+    Hymn-style SATB convention: the original melody IS the soprano voice.
+    The algorithm finds diatonic chords containing each melody note and
+    voices them below the melody (bass + tenor + alto for 4-voice mode;
+    just bass for 2-voice mode).
 
     voices: 2 (melody + bass) or 4 (SATB). Default 4.
-    Returns note data ready for add_notes on new tracks.
+
+    Response keys:
+      - melody: the input melody as passed in (identical pitches to soprano)
+      - soprano: same as melody (hymn-style convention)
+      - alto / tenor: inner voices (4-voice only)
+      - bass: root-aware bass line — BUG-B26 fix prevents tonic pedal
+      - chord_sequence: the chord chosen per melody note (degree + name)
+
+    BUG-B27: `soprano` and `melody` are intentionally identical — the
+    tool's job is to add harmony UNDER an existing melody, not replace
+    it. Both fields are returned so callers can pipe whichever makes
+    their downstream code cleaner.
 
     Processing time: 2-5s.
     """
@@ -477,6 +498,39 @@ def harmonize_melody(
         result_voices["tenor"] = []
 
     prev_bass_midi = None
+    prev_degree: Optional[int] = None
+
+    # BUG-B26 fix: the old chord-selection walked scale degrees in a fixed
+    # preference order [I, IV, V, vi, ii, iii, vii] and picked the FIRST
+    # one containing the melody note — in practice this meant I (tonic)
+    # won whenever the melody hit a chord tone of I, so the bass pedaled
+    # on the tonic. We now build ALL candidate diatonic chords that
+    # contain the note, then score them to prefer harmonic motion:
+    #   - strong penalty for picking the same chord twice in a row
+    #     (breaks the pedal pattern)
+    #   - mild preference for functional moves (I→IV, IV→V, V→I etc)
+    #   - fallback to the original [I, IV, V, …] order on ties
+    _DEGREE_ORDER = [0, 3, 4, 5, 1, 2, 6]  # I, IV, V, vi, ii, iii, vii
+
+    def _score_chord(degree: int, prev: Optional[int]) -> float:
+        score = 10.0 - _DEGREE_ORDER.index(degree) * 0.5
+        if prev is None:
+            return score
+        if degree == prev:
+            # Avoid repeating the same chord — the big lever for B26
+            score -= 20.0
+        # Functional pair bonuses (classical/pop voice-leading)
+        functional_pairs = {
+            (0, 3), (0, 4), (0, 5),  # I → IV, V, vi
+            (3, 4), (3, 0), (3, 1),  # IV → V, I, ii
+            (4, 0), (4, 5),          # V → I, vi
+            (5, 1), (5, 3),          # vi → ii, IV
+            (1, 4), (1, 6),          # ii → V, vii°
+            (6, 0), (6, 2),          # vii° → I, iii
+        }
+        if (prev, degree) in functional_pairs:
+            score += 5.0
+        return score
 
     for n in melody:
         melody_pitch = n["pitch"]
@@ -484,16 +538,23 @@ def harmonize_melody(
         dur = n["duration"]
         mel_pc = melody_pitch % 12
 
-        # Find the best diatonic chord containing this pitch
-        best_chord = None
-        for degree in [0, 3, 4, 5, 1, 2, 6]:  # I, IV, V, vi, ii, iii, vii
+        # Collect every diatonic chord that contains this melody note
+        candidates: list[tuple[int, dict]] = []
+        for degree in _DEGREE_ORDER:
             chord = engine.build_chord(degree, tonic, mode)
             if mel_pc in chord["pitch_classes"]:
-                best_chord = chord
-                break
+                candidates.append((degree, chord))
 
-        if best_chord is None:
-            best_chord = engine.build_chord(0, tonic, mode)
+        if not candidates:
+            candidates = [(0, engine.build_chord(0, tonic, mode))]
+
+        # Pick the highest-scoring candidate — break ties by preference order
+        candidates.sort(
+            key=lambda pair: (-_score_chord(pair[0], prev_degree),
+                              _DEGREE_ORDER.index(pair[0]))
+        )
+        best_degree, best_chord = candidates[0]
+        prev_degree = best_degree
 
         # Build MIDI pitches for the chord
         chord_midis = sorted([
@@ -553,10 +614,13 @@ def harmonize_melody(
                 "duration": dur, "velocity": int(vel * 0.7),
             })
 
+    # BUG-B27: expose the input melody under `melody` (alias of soprano)
+    # so downstream code doesn't have to guess which field carries it.
     result = {
         "key": _key_display(key_info),
         "voices": voices,
         "melody_notes": len(melody),
+        "melody": list(result_voices["soprano"]),
     }
     for voice_name, voice_notes in result_voices.items():
         if voice_notes:
@@ -608,9 +672,15 @@ def generate_countermelody(
 
     # Consonant intervals (semitones mod 12): P1, m3, M3, P4, P5, m6, M6, P8
     consonant = {0, 3, 4, 5, 7, 8, 9}
+    # BUG-B28: "imperfect" consonances (thirds + sixths) are more
+    # colorful than perfect ones (unison, 4th, 5th, octave). Prefer them
+    # so the countermelody doesn't collapse onto a static pedal of 1/4/5/8s.
+    imperfect_consonant = {3, 4, 8, 9}  # m3, M3, m6, M6
 
     counter_notes = []
     prev_cp = None
+    # Track recently-used pitches to reward range exploration (B28)
+    recent_pitches: list[int] = []
 
     for i, n in enumerate(melody):
         mel_pitch = n["pitch"]
@@ -626,29 +696,47 @@ def generate_countermelody(
 
                 score = 0.0
 
-                # Contrary motion bonus
+                # Prefer imperfect consonances (thirds + sixths) — more
+                # colorful than unison/4th/5th/octave. Without this the
+                # counter collapses onto perfect intervals (B28).
+                if iv in imperfect_consonant:
+                    score += 4.0
+
+                # Contrary motion bonus (amplified for B28)
                 if prev_cp is not None and i > 0:
                     mel_dir = mel_pitch - melody[i - 1]["pitch"]
                     cp_dir = cp - prev_cp
                     if (mel_dir > 0 and cp_dir < 0) or (mel_dir < 0 and cp_dir > 0):
-                        score += 10
+                        score += 15  # was 10 — make contrary motion dominant
                     # Penalize parallel perfect intervals
                     prev_iv = abs(prev_cp - melody[i - 1]["pitch"]) % 12
                     if prev_iv == iv and iv in (0, 7):
                         score -= 50
 
-                # Stepwise motion bonus
+                # Stepwise motion bonus — but don't let it pin us to one pitch
                 if prev_cp is not None:
                     step = abs(cp - prev_cp)
-                    if step <= 2:
+                    if step == 0:
+                        # Penalize exact repetition (was implicit-neutral)
+                        score -= 6
+                    elif step <= 2:
                         score += 5
                     elif step <= 4:
-                        score += 2
+                        score += 3
                     elif step > 7:
                         score -= 3
                 else:
                     score += 3
 
+                # BUG-B28: range-exploration bonus. Penalize pitches used
+                # in the last 4 notes; this forces the counter to walk
+                # through the pool instead of hovering on 2-3 pitches.
+                if cp in recent_pitches:
+                    score -= 4
+                # Modest bonus for pitches we haven't visited recently
+                if cp not in set(recent_pitches):
+                    score += 1
+
                 score += random.uniform(0, 2)
                 scored.append((cp, score))
 
@@ -657,6 +745,10 @@ def generate_countermelody(
 
             scored.sort(key=lambda x: -x[1])
             chosen = scored[0][0]
+            # Maintain a sliding window of the last 4 counter pitches
+            recent_pitches.append(chosen)
+            if len(recent_pitches) > 4:
+                recent_pitches.pop(0)
 
             counter_notes.append({
                 "pitch": chosen,

package/mcp_server/tools/tracks.py

@@ -106,7 +106,7 @@ def duplicate_track(ctx: Context, track_index: int) -> dict:
 
 @mcp.tool()
 def set_track_name(ctx: Context, track_index: int, name: str) -> dict:
-    """Rename a track."""
+    """Rename a track. The new name appears in both the Session and Arrangement views and survives session save."""
     _validate_track_index(track_index)
     if not name.strip():
         raise ValueError("Track name cannot be empty")

package/mcp_server/tools/transport.py

@@ -62,7 +62,7 @@ def start_playback(ctx: Context) -> dict:
 
 @mcp.tool()
 def stop_playback(ctx: Context) -> dict:
-    """Stop playback."""
+    """Stop playback — halts the session transport and the arrangement cursor returns to its last position."""
     return _get_ableton(ctx).send_command("stop_playback")
 
 

package/mcp_server/transition_engine/critics.py

@@ -270,17 +270,24 @@ def run_gesture_fit_critic(
     boundary = plan.boundary
     archetype = plan.archetype
 
-    # Check if the section pair matches any of the archetype's use cases
-    pair_tags = {
-        f"{boundary.from_type}_to_{boundary.to_type}",
-        boundary.from_type,
-        boundary.to_type,
-    }
-    use_case_match = any(
-        tag in uc or uc in tag
-        for tag in pair_tags
-        for uc in archetype.use_cases
-    )
+    # Check if the section pair matches any of the archetype's use cases.
+    # BUG-B15: "any_section_change" is a wildcard that matches any transition —
+    # honor it explicitly so archetypes documented as universal don't get
+    # flagged as mismatched on specific pairs like intro→build.
+    WILDCARDS = {"any_section_change", "any"}
+    if any(uc in WILDCARDS for uc in archetype.use_cases):
+        use_case_match = True
+    else:
+        pair_tags = {
+            f"{boundary.from_type}_to_{boundary.to_type}",
+            boundary.from_type,
+            boundary.to_type,
+        }
+        use_case_match = any(
+            tag in uc or uc in tag
+            for tag in pair_tags
+            for uc in archetype.use_cases
+        )
 
     if not use_case_match:
         issues.append(TransitionIssue(

package/mcp_server/translation_engine/tools.py

@@ -6,11 +6,19 @@ then delegates to pure-computation critics.
 
 from __future__ import annotations
 
+import logging
+
 from fastmcp import Context
 
 from ..server import mcp
 from .critics import build_translation_report, run_all_translation_critics
 
+# Logger defined at module top: _fetch_translation_data below calls
+# logger.debug on an exception path. The previous version buried the logger
+# definition inside a docstring mid-file, which meant the name was never
+# actually bound at module level — any exception path would raise NameError.
+logger = logging.getLogger(__name__)
+
 
 # ── Helpers ─────────────────────────────────────────────────────────
 
@@ -97,10 +105,6 @@ def get_translation_issues(ctx: Context) -> dict:
 
     Lighter than check_translation — returns only detected issues
     from the 5 playback robustness critics.
-import logging
-
-logger = logging.getLogger(__name__)
-
     """
     mix_snapshot = _fetch_translation_data(ctx)
     issues = run_all_translation_critics(mix_snapshot)

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.10.6",
+  "version": "1.10.8",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 320 tools, 43 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
+  "description": "Agentic production system for Ableton Live 12 — 324 tools, 45 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",
   "license": "BSL-1.1",
   "type": "commonjs",
@@ -43,5 +43,27 @@
   ],
   "engines": {
     "node": ">=18.0.0"
-  }
+  },
+  "files": [
+    "bin/**/*.js",
+    "installer/**/*.js",
+    "mcp_server/**/*.py",
+    "mcp_server/**/*.json",
+    "mcp_server/**/*.yaml",
+    "mcp_server/**/*.md",
+    "mcp_server/**/*.db",
+    "remote_script/**/*.py",
+    "m4l_device/LivePilot_Analyzer.amxd",
+    "m4l_device/LivePilot_Analyzer.adv",
+    "m4l_device/livepilot_bridge.js",
+    "m4l_device/BUILD_GUIDE.md",
+    "requirements.txt",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "server.json",
+    "!**/__pycache__/**",
+    "!**/*.pyc",
+    "!**/.DS_Store"
+  ]
 }

package/remote_script/LivePilot/__init__.py

@@ -5,9 +5,10 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.10.6"
+__version__ = "1.10.8"
 
 from _Framework.ControlSurface import ControlSurface
+from . import router
 from .server import LivePilotServer
 from . import transport    # noqa: F401  — registers transport handlers
 from . import tracks       # noqa: F401  — registers track handlers
@@ -23,8 +24,82 @@ from . import clip_automation   # noqa: F401  — registers clip automation hand
 from . import version_detect    # noqa: F401  — version detection
 
 
+# ── Reload plumbing (BUG-B-reload, Batch 20) ──────────────────────────────
+# Ableton keeps `sys.modules["LivePilot.*"]` cached across Control Surface
+# toggles. Without intervention, edits to handler files don't take effect
+# until a full Ableton restart — the toggle just re-instantiates the
+# ControlSurface class without re-importing submodules.
+#
+# Fix: track whether this is the first create_instance call per
+# interpreter lifetime. On subsequent calls, force-reload the router
+# (which clears _handlers) and every handler module (which re-fires
+# @register decorators with the updated code). Result: a Control Surface
+# toggle now behaves like a fresh module reload, so live-editing mixing.py
+# / devices.py / etc. and re-toggling is enough — no Ableton restart.
+
+_FIRST_CREATE_INSTANCE = True
+
+_HANDLER_MODULES = (
+    transport, tracks, clips, notes, devices, scenes,
+    mixing, browser, arrangement, diagnostics,
+    clip_automation, version_detect,
+)
+
+
+def _force_reload_handlers(cs=None):
+    """Force Python to re-read the handler modules from disk.
+
+    Called on every create_instance() except the first, so edits to
+    handler files take effect via Control Surface toggle without
+    restarting Ableton. Order matters: router first (clears _handlers),
+    then each handler module (re-registers its @register decorators).
+
+    When ``cs`` is provided, reload exceptions are logged through the
+    ControlSurface so a SyntaxError / NameError in an edited handler is
+    surfaced in Live's status log instead of silently swallowed. The
+    previous ``except Exception: pass`` turned any bad handler into a
+    silent NOT_FOUND at dispatch time with no hint that reload had failed.
+    """
+    import importlib
+    def _log(msg):
+        if cs is None:
+            return
+        try:
+            cs.log_message("[LivePilot] " + msg)
+        except Exception:
+            pass
+
+    try:
+        importlib.reload(router)
+    except Exception as exc:
+        _log("reload(router) FAILED — %s: %s. Handlers will be "
+             "stale until Ableton restart." % (type(exc).__name__, exc))
+    for mod in _HANDLER_MODULES:
+        try:
+            importlib.reload(mod)
+        except Exception as exc:
+            # Don't block Ableton startup on a single bad reload, but do
+            # tell the user what happened — the stale handler will keep
+            # serving the OLD code until a full restart.
+            _log("reload(%s) FAILED — %s: %s. Handler is stale." % (
+                getattr(mod, "__name__", "?"),
+                type(exc).__name__,
+                exc,
+            ))
+
+
 def create_instance(c_instance):
-    """Factory function called by Ableton Live."""
+    """Factory function called by Ableton Live.
+
+    Called once on initial Control Surface enable, AND every time the
+    user toggles the Control Surface off and on. The reload path below
+    makes the toggle behave like a fresh import — crucial for dev
+    ergonomics when iterating on mixing.py / devices.py / etc.
+    """
+    global _FIRST_CREATE_INSTANCE
+    if not _FIRST_CREATE_INSTANCE:
+        _force_reload_handlers(cs=c_instance)
+    _FIRST_CREATE_INSTANCE = False
     return LivePilot(c_instance)
 
 

package/remote_script/LivePilot/arrangement.py

@@ -407,11 +407,21 @@ def modify_arrangement_notes(song, params):
     for note in all_notes:
         note_map[note.note_id] = note
 
+    # Two-pass: validate all note_ids BEFORE mutating any notes. See the
+    # identical fix in notes.py:modify_notes — partial mid-loop mutation on
+    # the C++ NoteVector was leaving the clip in a half-modified state that
+    # never got committed.
+    missing = [int(mod["note_id"]) for mod in modifications
+               if int(mod["note_id"]) not in note_map]
+    if missing:
+        raise ValueError(
+            "Note IDs not found in arrangement clip: %s. "
+            "No modifications applied." % missing
+        )
+
     modified_count = 0
     for mod in modifications:
         note_id = int(mod["note_id"])
-        if note_id not in note_map:
-            raise ValueError("Note ID %d not found in clip" % note_id)
         note = note_map[note_id]
         if "pitch" in mod:
             note.pitch = int(mod["pitch"])

package/remote_script/LivePilot/browser.py

@@ -287,11 +287,20 @@ def load_browser_item(song, params):
     # and use the subcategory or the full fragment for matching
     if "FileId_" in device_name:
         # URI contains an internal file ID — name-based search won't work.
-        # Try one more URI pass with a much higher iteration limit.
+        # We fall back to one URI walk, but with a TIGHT iteration budget:
+        # this runs synchronously on Ableton's audio/main thread, and the
+        # previous 200 000-node walk could stall audio and GUI for several
+        # seconds on large libraries (documented in CLAUDE.md).
+        #
+        # If the item isn't found inside the budget, we return a clean
+        # STATE_ERROR pointing the caller at search_browser(), which does
+        # the same walk lazily from a cached Python-side index without
+        # hogging the audio thread.
         _iterations[0] = 0
-        DEEP_MAX = 200000
+        DEEP_MAX = 20000        # was 200_000 — 10x reduction
+        DEEP_DEPTH_MAX = 8       # was 12 — shallower depth is usually enough
         def find_by_uri_deep(parent, target_uri, depth=0):
-            if depth > 12 or _iterations[0] > DEEP_MAX:
+            if depth > DEEP_DEPTH_MAX or _iterations[0] > DEEP_MAX:
                 return None
             try:
                 children = list(parent.children)
@@ -326,9 +335,10 @@ def load_browser_item(song, params):
                 }
 
         raise ValueError(
-            "Item '%s' not found in browser (FileId URI — try "
-            "search_browser to find the item, then use find_and_load_device "
-            "with the exact name instead)" % uri
+            "Item '%s' not found inside deep-scan budget (FileId URI). "
+            "Use search_browser(query=...) to locate it without stalling "
+            "Ableton's audio thread, then call load_browser_item with the "
+            "returned URI." % uri
         )
 
     for sep in (":", "/"):

package/remote_script/LivePilot/clips.py

@@ -36,6 +36,16 @@ def get_clip_info(song, params):
     if clip.is_audio_clip:
         result["warping"] = clip.warping
         result["warp_mode"] = clip.warp_mode
+        # BUG-A4: expose pitch/gain so callers can reason about sample
+        # transposition vs session key. Pitch is in semitones (int, -48..+48),
+        # pitch_fine in cents (-50..+50), gain linear (normalized 0..1 in Live).
+        # Some Live builds expose these as None on freshly-recorded clips
+        # before a warp pass; wrap in try/except for safety.
+        for attr in ("pitch_coarse", "pitch_fine", "gain"):
+            try:
+                result[attr] = getattr(clip, attr)
+            except AttributeError:
+                pass
 
     return result
 
@@ -202,6 +212,65 @@ def set_clip_launch(song, params):
     }
 
 
+@register("set_clip_pitch")
+def set_clip_pitch(song, params):
+    """Set pitch/gain on an audio clip (BUG-A5).
+
+    Audio clips only — MIDI clips raise ValueError.
+
+    Parameters
+    ----------
+    track_index, clip_index : int
+    coarse : int, optional        -- semitones, -48..+48
+    fine   : float, optional      -- cents, -50.0..+50.0
+    gain   : float, optional      -- linear normalized (0..1 in Live)
+
+    At least one of (coarse, fine, gain) must be provided.
+    """
+    track_index = int(params["track_index"])
+    clip_index = int(params["clip_index"])
+    clip = get_clip(song, track_index, clip_index)
+
+    if clip.is_midi_clip:
+        raise ValueError("set_clip_pitch only works on audio clips")
+
+    coarse = params.get("coarse")
+    fine = params.get("fine")
+    gain = params.get("gain")
+
+    if coarse is None and fine is None and gain is None:
+        raise ValueError(
+            "Provide at least one of: coarse (semitones), fine (cents), gain (0-1)"
+        )
+
+    if coarse is not None:
+        c = int(coarse)
+        if c < -48 or c > 48:
+            raise ValueError("coarse must be in -48..+48 semitones")
+        clip.pitch_coarse = c
+    if fine is not None:
+        f = float(fine)
+        if f < -50.0 or f > 50.0:
+            raise ValueError("fine must be in -50..+50 cents")
+        clip.pitch_fine = f
+    if gain is not None:
+        g = float(gain)
+        if g < 0.0 or g > 1.0:
+            raise ValueError("gain must be in 0..1")
+        clip.gain = g
+
+    result = {
+        "track_index": track_index,
+        "clip_index": clip_index,
+    }
+    for attr in ("pitch_coarse", "pitch_fine", "gain"):
+        try:
+            result[attr] = getattr(clip, attr)
+        except AttributeError:
+            pass
+    return result
+
+
 @register("set_clip_warp_mode")
 def set_clip_warp_mode(song, params):
     """Set warp mode for an audio clip."""

package/remote_script/LivePilot/devices.py

@@ -199,17 +199,22 @@ def toggle_device(song, params):
     track = get_track(song, track_index)
     device = get_device(track, device_index)
 
-    # Find the "Device On" parameter by name (safer than assuming index 0)
+    # Find the "Device On" parameter by name — the previous fallback
+    # blindly assumed parameters[0] was an on/off switch, which for many
+    # devices is actually "Filter Frequency", "Gain", or similar. The
+    # fallback silently mutated an arbitrary parameter while reporting
+    # is_active as if toggling had worked. Now refuse to guess.
     on_param = None
     for p in device.parameters:
         if p.name == "Device On":
             on_param = p
             break
     if on_param is None:
-        # Fallback to parameter 0 for devices that don't use "Device On"
-        if not list(device.parameters):
-            raise ValueError("Device '%s' has no parameters to toggle" % device.name)
-        on_param = device.parameters[0]
+        raise ValueError(
+            "Device '%s' exposes no 'Device On' parameter and cannot be "
+            "toggled programmatically. Use delete_device or disable it "
+            "through the UI." % device.name
+        )
 
     on_param.value = 1.0 if active else 0.0
     return {"name": device.name, "is_active": on_param.value > 0.5}