livepilot 1.4.0 → 1.4.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.4.1] — 2026-03-18
+
+### Fixes
+- Browser search now enforces global 10,000 iteration budget across all categories (was resetting per-category)
+- `_search_recursive` returns early when `max_results` is reached instead of scanning remaining siblings
+- Narrowed 29 broad `except Exception` catches to specific types (`AttributeError`, `OSError`, `ValueError`) across browser, devices, mixing, and server modules
+- Kept `except Exception` only at the 3 outermost dispatch boundaries (router, command processor, logger)
+
 ## [1.4.0] — 2026-03-18
 
 ### Added

package/README.md

@@ -19,26 +19,33 @@ Every command goes through Ableton's official Live Object Model API. No hacks, n
 
 ---
 
-## Build Your Own AI Producer
+## Train Your Own AI Producer
 
-LivePilot isn't just a tool collection — it's a framework for building **your own personalized AI production partner**.
+LivePilot ships with 104 tools and a deep reference corpus — genre-specific drum patterns, chord voicings, sound design recipes, mixing templates, song structures. Day one, it already knows how music works. But the tools are just the starting point.
 
-Out of the box, the agent ships with a deep reference corpus: genre-specific drum patterns, chord voicings, sound design recipes, mixing templates, song structures. It knows how music works. But that's just the starting point.
+**The real product is the agent you build on top of them.**
 
-**The real power is training it to work like you.**
+Every producer has a sonic identity — the swing amounts they reach for, the drum kits that feel right, the FX chains they keep coming back to, the way they EQ a vocal bus. Most AI tools ignore all of this. Every session starts blank. LivePilot is different: it has a technique memory system that turns your production decisions into a persistent, searchable stylistic palette the agent learns from over time.
 
-Every time you produce something you like — a beat, a device chain, a mixing setup — you tell the agent to remember it. It doesn't just store raw data. It writes a rich stylistic analysis: *what makes this groove feel the way it does, what the sonic texture is, what it pairs with, what artists it evokes.* Over sessions, your saved techniques become a **stylistic fingerprint** the agent understands and draws from.
+Here's how you train it:
 
-Here's how you build your agent's palette:
+1. **Produce something you like** — a beat, a device chain, a mixing setup, a synth patch
+2. **Tell the agent to save it** — "remember this groove" / "save this reverb chain"
+3. **The agent writes a stylistic analysis** — not just raw MIDI data, but *what makes it work*: the rhythmic feel, the sonic texture, the mood, what it pairs with, what artists it evokes
+4. **Your library grows** — rate and favorite the best techniques, tag them by genre or mood, build categories
+5. **The agent develops taste** — next time you say "make me a beat", it checks your library, reads your tendencies, and creates something new that sounds like you
 
-- **Save beats you like** — "remember this groove" — the agent captures the pattern AND analyzes why it works
-- **Pin your go-to sounds** — "save this reverb chain" — instant recall next time, with context about when to use it
-- **Set preferences** — "I always want Utility on every track" — the agent adapts its workflow to match yours
-- **Curate over time** — rate, favorite, and refine saved techniques — the best ones float to the top
+This isn't a preset recall system. The agent doesn't copy stored patterns — it understands the *qualities* across your saved techniques (the swing you prefer, the harmonic language you gravitate toward, the density of your arrangements) and uses that understanding to inform new creative decisions.
 
-The next time you say "make me a beat", the agent checks your library. It doesn't copy — it reads your tendencies (the swing you like, the kits you reach for, your harmonic language) and creates something **new that sounds like you**. Say "ignore my history" and it starts fresh. Say "use that boom bap groove" and it replays exactly what you saved.
+**Three modes, always under your control:**
 
-**You're not configuring software. You're building a creative relationship.**
+- **Informed** (default) — the agent consults your memory and lets it influence creative choices naturally
+- **Fresh** — "ignore my history" / "something completely new" — blank slate, pure musical knowledge, zero influence from saved techniques
+- **Explicit recall** — "use that boom bap beat I saved" — direct retrieval and replay
+
+The memory is both a drawer and a personality. You put things in, you take things out, and the agent develops taste from what you've collected — but you can always tell it to forget everything and start fresh.
+
+**You're not configuring software. You're building a creative partner that gets better the more you use it.**
 
 ---
 
@@ -286,21 +293,9 @@ What makes it different from a generic AI with tools is **what it knows**. The a
 
 But the shipped corpus is just the floor. The real value builds over time.
 
-### Technique Memory — Your Evolving Stylistic Palette
-
-Most AI music tools are stateless — every session starts blank. LivePilot remembers.
-
-When you make something you like — a beat, a device chain, a mixing setup, a favorite preset — you tell the agent to save it. But it doesn't just store the raw MIDI data or parameter values. It writes a **stylistic analysis**: what makes this groove feel the way it does, what the sonic character is, what it pairs well with, what artists or styles it evokes. Over time, your saved techniques become a **stylistic fingerprint** — a palette the agent understands.
-
-The next time you say "make me a beat", the agent checks your library first. It doesn't copy a stored pattern — it reads across your saved techniques, understands your tendencies (the swing amounts you like, the kits you reach for, your harmonic language), and creates something **new that sounds like you**. It's the difference between an assistant that follows instructions and one that knows your taste.
-
-Three modes, always under your control:
-
-- **Informed** (default) — the agent consults your memory and lets it influence creative choices
-- **Fresh** — say "ignore my history" and the agent starts with a blank slate, pure musical knowledge
-- **Explicit recall** — say "use that boom bap beat I saved" for direct retrieval and replay
+### Technique Memory
 
-The memory is a drawer and a personality. You put things in, you take things out, and the agent develops taste from what you've collected — but you can always override it.
+8 tools for saving, searching, and replaying production techniques. Every saved technique includes a rich stylistic analysis written by the agent — not just raw data, but *what makes it work* and when to use it. See "Train Your Own AI Producer" above for how this shapes the agent over time.
 
 ### Core Skill
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "AI copilot for Ableton Live 12 — 104 MCP tools for music production, sound design, and mixing",
   "author": "Pilot Studio",

package/plugin/agents/livepilot-producer/AGENT.md

@@ -17,19 +17,15 @@ You are LivePilot Producer — an autonomous music production agent for Ableton
 Given a high-level description, you:
 
 1. **Plan** — decide tempo, key, track layout, instrument choices, arrangement structure
-1.5. **Consult memory** (unless user requests fresh exploration):
-     Call `memory_recall` with a query matching the task (limit=5).
-     Read the returned qualities and let them shape your plan — kit choices,
-     tempo range, rhythmic approach, sound palette. Don't copy — be influenced.
-     If the user says "fresh" / "ignore history" / "something new" → skip this step.
-2. **Build tracks** — create and name tracks with appropriate colors
-3. **Load instruments** — find and load the right synths, drum kits, and samplers
-4. **HEALTH CHECK** — verify every track actually produces sound (see below)
-5. **Program patterns** — write MIDI notes that fit the genre and style
-6. **Add effects** — load and configure effect chains for the desired sound
-7. **HEALTH CHECK** — verify effects aren't pass-throughs (Dry/Wet > 0, Drive set, etc.)
-8. **Mix** — balance volumes, set panning, configure sends
-9. **Final verify** — `get_session_info`, fire scenes, confirm audio output
+2. **Consult memory** (unless user requests fresh exploration) — call `memory_recall` with a query matching the task (limit=5). Read the returned qualities and let them shape your plan: kit choices, tempo range, rhythmic approach, sound palette. Don't copy — be influenced. If the user says "fresh" / "ignore history" / "something new", skip this step entirely.
+3. **Build tracks** — create and name tracks with appropriate colors
+4. **Load instruments** — find and load the right synths, drum kits, and samplers
+5. **HEALTH CHECK** — verify every track actually produces sound (see below)
+6. **Program patterns** — write MIDI notes that fit the genre and style
+7. **Add effects** — load and configure effect chains for the desired sound
+8. **HEALTH CHECK** — verify effects aren't pass-throughs (Dry/Wet > 0, Drive set, etc.)
+9. **Mix** — balance volumes, set panning, configure sends
+10. **Final verify** — `get_session_info`, fire scenes, confirm audio output
 
 ## Mandatory Track Health Checks
 

package/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "AI copilot for Ableton Live 12 — 104 MCP tools for music production, sound design, and mixing",
   "author": "Pilot Studio",
   "skills": [

package/remote_script/LivePilot/browser.py

@@ -82,14 +82,17 @@ def _search_recursive(item, name_filter, loadable_only, results, depth, max_dept
             }
             try:
                 entry["uri"] = child.uri
-            except Exception:
+            except AttributeError:
                 entry["uri"] = None
             results.append(entry)
         if child.is_folder:
+            before = len(results)
             _search_recursive(
                 child, name_filter, loadable_only, results, depth + 1, max_depth,
                 max_results
             )
+            if len(results) >= max_results:
+                return
 
 
 @register("get_browser_tree")
@@ -136,7 +139,7 @@ def get_browser_items(song, params):
         if child.is_loadable:
             try:
                 entry["uri"] = child.uri
-            except Exception:
+            except AttributeError:
                 entry["uri"] = None
         result.append(entry)
     return {"path": path, "items": result}
@@ -186,7 +189,7 @@ def load_browser_item(song, params):
     for attr in category_attrs:
         try:
             categories.append(getattr(browser, attr))
-        except Exception:
+        except AttributeError:
             pass
 
     _iterations = [0]
@@ -198,7 +201,7 @@ def load_browser_item(song, params):
             return None
         try:
             children = list(parent.children)
-        except Exception:
+        except AttributeError:
             return None
         for child in children:
             _iterations[0] += 1
@@ -207,7 +210,7 @@ def load_browser_item(song, params):
             try:
                 if child.uri == target_uri and child.is_loadable:
                     return child
-            except Exception:
+            except AttributeError:
                 pass
             result = find_by_uri(child, target_uri, depth + 1)
             if result is not None:
@@ -215,7 +218,6 @@ def load_browser_item(song, params):
         return None
 
     for category in categories:
-        _iterations[0] = 0
         found = find_by_uri(category, uri)
         if found is not None:
             song.view.selected_track = track
@@ -248,13 +250,14 @@ def load_browser_item(song, params):
             break
 
     target = device_name.lower()
+    _iterations[0] = 0
 
     def find_by_name(parent, depth=0):
         if depth > 8 or _iterations[0] > MAX_ITERATIONS:
             return None
         try:
             children = list(parent.children)
-        except Exception:
+        except AttributeError:
             return None
         for child in children:
             _iterations[0] += 1
@@ -269,7 +272,6 @@ def load_browser_item(song, params):
         return None
 
     for category in categories:
-        _iterations[0] = 0
         found = find_by_name(category)
         if found is not None:
             song.view.selected_track = track
@@ -311,14 +313,14 @@ def get_device_presets(song, params):
             return
         try:
             children = list(item.children)
-        except Exception:
+        except AttributeError:
             return
         for child in children:
             if child.is_loadable and not child.is_folder:
                 entry = {"name": child.name}
                 try:
                     entry["uri"] = child.uri
-                except Exception:
+                except AttributeError:
                     entry["uri"] = None
                 results.append(entry)
             elif child.is_folder:

package/remote_script/LivePilot/devices.py

@@ -30,7 +30,7 @@ def get_device_info(song, params):
     }
     try:
         result["type"] = device.type
-    except Exception:
+    except AttributeError:
         result["type"] = None
     return result
 
@@ -196,7 +196,7 @@ def load_device_by_uri(song, params):
     for attr in category_attrs:
         try:
             categories.append(getattr(browser, attr))
-        except Exception:
+        except AttributeError:
             pass
 
     _iterations = [0]
@@ -208,7 +208,7 @@ def load_device_by_uri(song, params):
             return None
         try:
             children = list(parent.children)
-        except Exception:
+        except AttributeError:
             return None
         for child in children:
             _iterations[0] += 1
@@ -217,7 +217,7 @@ def load_device_by_uri(song, params):
             try:
                 if child.uri == target_uri and child.is_loadable:
                     return child
-            except Exception:
+            except AttributeError:
                 pass
             result = find_by_uri(child, target_uri, depth + 1)
             if result is not None:
@@ -225,7 +225,6 @@ def load_device_by_uri(song, params):
         return None
 
     for category in categories:
-        _iterations[0] = 0
         found = find_by_uri(category, uri)
         if found is not None:
             song.view.selected_track = track
@@ -252,13 +251,14 @@ def load_device_by_uri(song, params):
             break
 
     target = device_name.lower()
+    _iterations[0] = 0
 
     def find_by_name(parent, depth=0):
         if depth > 8 or _iterations[0] > MAX_ITERATIONS:
             return None
         try:
             children = list(parent.children)
-        except Exception:
+        except AttributeError:
             return None
         for child in children:
             _iterations[0] += 1
@@ -273,7 +273,6 @@ def load_device_by_uri(song, params):
         return None
 
     for category in categories:
-        _iterations[0] = 0
         found = find_by_name(category)
         if found is not None:
             song.view.selected_track = track
@@ -307,7 +306,7 @@ def find_and_load_device(song, params):
             return None
         try:
             children = list(item.children)
-        except Exception:
+        except AttributeError:
             return None
         for child in children:
             iterations += 1
@@ -332,11 +331,11 @@ def find_and_load_device(song, params):
     for attr in category_attrs:
         try:
             categories.append(getattr(browser, attr))
-        except Exception:
+        except AttributeError:
             pass
 
     for category in categories:
-        iterations = 0  # Reset per category so each gets a fair search budget
+        iterations = 0
         found = search_children(category)
         if found is not None:
             song.view.selected_track = track

package/remote_script/LivePilot/mixing.py

@@ -97,19 +97,19 @@ def get_track_routing(song, params):
     result = {"index": track_index}
     try:
         result["input_routing_type"] = track.input_routing_type.display_name
-    except Exception:
+    except AttributeError:
         result["input_routing_type"] = None
     try:
         result["input_routing_channel"] = track.input_routing_channel.display_name
-    except Exception:
+    except AttributeError:
         result["input_routing_channel"] = None
     try:
         result["output_routing_type"] = track.output_routing_type.display_name
-    except Exception:
+    except AttributeError:
         result["output_routing_type"] = None
     try:
         result["output_routing_channel"] = track.output_routing_channel.display_name
-    except Exception:
+    except AttributeError:
         result["output_routing_channel"] = None
     return result
 

package/remote_script/LivePilot/server.py

@@ -84,7 +84,7 @@ class LivePilotServer(object):
         if self._server_socket:
             try:
                 self._server_socket.close()
-            except Exception:
+            except OSError:
                 pass
         if self._thread and self._thread.is_alive():
             self._thread.join(timeout=3)
@@ -109,7 +109,7 @@ class LivePilotServer(object):
             self._server_socket.listen(2)
             self._server_socket.settimeout(1.0)
             self._log("Listening on %s:%d" % (self._host, self._port))
-        except Exception as exc:
+        except OSError as exc:
             self._log("Failed to bind: %s" % exc)
             return
 
@@ -132,37 +132,37 @@ class LivePilotServer(object):
                                 }
                             }) + "\n"
                             client.sendall(reject.encode("utf-8"))
-                        except Exception:
+                        except OSError:
                             pass
                         try:
                             client.close()
-                        except Exception:
+                        except OSError:
                             pass
                         continue
                     self._client_connected = True
                 self._log("Client connected from %s:%d" % addr)
                 try:
                     self._handle_client(client)
-                except Exception as exc:
+                except OSError as exc:
                     self._log("Client error: %s" % exc)
                 finally:
                     with self._client_lock:
                         self._client_connected = False
                     try:
                         client.close()
-                    except Exception:
+                    except OSError:
                         pass
                     self._log("Client disconnected")
             except socket.timeout:
                 continue
-            except Exception:
+            except OSError:
                 if self._running:
                     self._log("Accept error")
                 break
 
         try:
             self._server_socket.close()
-        except Exception:
+        except OSError:
             pass
 
     def _handle_client(self, client):
@@ -182,7 +182,7 @@ class LivePilotServer(object):
                         self._process_line(client, line)
             except socket.timeout:
                 continue
-            except Exception as exc:
+            except OSError as exc:
                 self._log("Recv error: %s" % exc)
                 break
 
@@ -190,7 +190,7 @@ class LivePilotServer(object):
         """Parse one JSON command, queue it for main thread, wait for result."""
         try:
             command = json.loads(line)
-        except Exception as exc:
+        except (ValueError, TypeError) as exc:
             resp = {
                 "id": "unknown",
                 "ok": False,
@@ -282,5 +282,5 @@ class LivePilotServer(object):
         from .utils import serialize_json
         try:
             client.sendall(serialize_json(response).encode("utf-8"))
-        except Exception as exc:
+        except OSError as exc:
             self._log("Send error: %s" % exc)