livepilot 1.3.0 → 1.4.0

package/mcp_server/tools/memory.py

@@ -0,0 +1,198 @@
+"""Memory MCP tools — technique library for saving, recalling, and replaying patterns.
+
+8 tools for the agent's long-term memory system.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from fastmcp import Context
+
+from ..server import mcp
+from ..memory.technique_store import TechniqueStore
+
+_store = TechniqueStore()
+
+
+def _get_store() -> TechniqueStore:
+    return _store
+
+
+@mcp.tool()
+def memory_learn(
+    ctx: Context,
+    name: str,
+    type: str,
+    qualities: dict,
+    payload: dict,
+    tags: Optional[list] = None,
+) -> dict:
+    """Save a new technique to the memory library with stylistic qualities. type must be one of: beat_pattern, device_chain, mix_template, browser_pin, preference. qualities must include at minimum a 'summary' field."""
+    return _get_store().save(name=name, type=type, qualities=qualities, payload=payload, tags=tags)
+
+
+@mcp.tool()
+def memory_recall(
+    ctx: Context,
+    query: Optional[str] = None,
+    type: Optional[str] = None,
+    tags: Optional[list] = None,
+    limit: int = 10,
+) -> dict:
+    """Search the technique library by text query and/or filters. Returns summaries (no payload)."""
+    results = _get_store().search(query=query, type_filter=type, tags=tags, limit=limit)
+    return {"count": len(results), "techniques": results}
+
+
+@mcp.tool()
+def memory_get(ctx: Context, technique_id: str) -> dict:
+    """Fetch a full technique by ID, including payload for replay."""
+    return _get_store().get(technique_id)
+
+
+@mcp.tool()
+def memory_replay(ctx: Context, technique_id: str, adapt: bool = False) -> dict:
+    """Retrieve a technique with a replay plan for the agent to execute. adapt=false: returns step-by-step replay plan for exact reconstruction. adapt=true: returns technique for creative adaptation."""
+    store = _get_store()
+    technique = store.get(technique_id)
+    store.increment_replay(technique_id)
+
+    mode = "adapt" if adapt else "exact"
+
+    if adapt:
+        steps = [
+            "Read qualities and payload as inspiration",
+            "Create something new that matches the stylistic palette",
+        ]
+    else:
+        steps = _generate_replay_steps(technique)
+
+    return {
+        "technique": technique,
+        "replay_plan": {
+            "mode": mode,
+            "type": technique["type"],
+            "steps": steps,
+        },
+    }
+
+
+def _generate_replay_steps(technique: dict) -> list[str]:
+    """Generate human-readable replay steps based on technique type."""
+    t_type = technique["type"]
+    payload = technique.get("payload", {})
+
+    if t_type == "beat_pattern":
+        steps = []
+        kit = payload.get("kit_name")
+        if kit:
+            steps.append(f"Load kit '{kit}' using search_browser + load_browser_item")
+        steps.append(
+            f"Create a MIDI clip using create_clip "
+            f"(length={payload.get('clip_length', 4)} beats)"
+        )
+        notes = payload.get("notes", [])
+        if notes:
+            steps.append(f"Add {len(notes)} notes using add_notes with the stored note data")
+        tempo = payload.get("tempo")
+        if tempo:
+            steps.append(f"Set tempo to {tempo} BPM using set_tempo")
+        return steps or ["Replay the beat pattern from the stored payload"]
+
+    elif t_type == "device_chain":
+        steps = []
+        devices = payload.get("devices", [])
+        for i, dev in enumerate(devices):
+            dev_name = dev.get("name", f"device {i + 1}")
+            steps.append(f"Load '{dev_name}' using find_and_load_device")
+            params = dev.get("params", {})
+            if params:
+                steps.append(
+                    f"Set {len(params)} parameters on '{dev_name}' using batch_set_parameters"
+                )
+        return steps or ["Load the device chain from the stored payload"]
+
+    elif t_type == "mix_template":
+        steps = []
+        returns = payload.get("returns", [])
+        if returns:
+            steps.append(
+                f"Create {len(returns)} return tracks using create_return_track"
+            )
+            for ret in returns:
+                devices = ret.get("devices", [])
+                for dev in devices:
+                    dev_name = dev if isinstance(dev, str) else dev.get("name", "device")
+                    steps.append(
+                        f"Load '{dev_name}' on return track using find_and_load_device"
+                    )
+        sends = payload.get("sends_pattern", {})
+        if sends:
+            steps.append(
+                "Apply send levels from sends_pattern "
+                "(note: role names must be resolved to track indices by the agent)"
+            )
+        return steps or ["Apply the mix template from the stored payload"]
+
+    elif t_type == "browser_pin":
+        uri = payload.get("uri", "")
+        name = payload.get("name", "item")
+        steps = [f"Load browser item '{name}' by URI '{uri}' using load_browser_item"]
+        return steps
+
+    elif t_type == "preference":
+        key = payload.get("key", "preference")
+        value = payload.get("value", "")
+        steps = [f"Apply preference '{key}' = '{value}'"]
+        return steps
+
+    return ["Replay the technique from the stored payload"]
+
+
+@mcp.tool()
+def memory_list(
+    ctx: Context,
+    type: Optional[str] = None,
+    tags: Optional[list] = None,
+    sort_by: str = "updated_at",
+    limit: int = 20,
+) -> dict:
+    """Browse the technique library with optional filtering."""
+    results = _get_store().list_techniques(
+        type_filter=type, tags=tags, sort_by=sort_by, limit=limit
+    )
+    return {"count": len(results), "techniques": results}
+
+
+@mcp.tool()
+def memory_favorite(
+    ctx: Context,
+    technique_id: str,
+    favorite: Optional[bool] = None,
+    rating: Optional[int] = None,
+) -> dict:
+    """Star and/or rate a technique (rating 0-5)."""
+    return _get_store().favorite(
+        technique_id=technique_id, favorite=favorite, rating=rating
+    )
+
+
+@mcp.tool()
+def memory_update(
+    ctx: Context,
+    technique_id: str,
+    name: Optional[str] = None,
+    tags: Optional[list] = None,
+    qualities: Optional[dict] = None,
+) -> dict:
+    """Update name, tags, or qualities on an existing technique. Qualities are merged (lists replace)."""
+    return _get_store().update(
+        technique_id=technique_id, name=name, tags=tags, qualities=qualities
+    )
+
+
+@mcp.tool()
+def memory_delete(ctx: Context, technique_id: str) -> dict:
+    """Delete a technique from the library (creates backup first)."""
+    return _get_store().delete(technique_id)

package/mcp_server/tools/mixing.py

@@ -3,6 +3,10 @@
 8 tools matching the Remote Script mixing domain.
 """
 
+from __future__ import annotations
+
+from typing import Optional
+
 from fastmcp import Context
 
 from ..server import mcp
@@ -96,10 +100,10 @@ def get_track_routing(ctx: Context, track_index: int) -> dict:
 def set_track_routing(
     ctx: Context,
     track_index: int,
-    input_type: str | None = None,
-    input_channel: str | None = None,
-    output_type: str | None = None,
-    output_channel: str | None = None,
+    input_type: Optional[str] = None,
+    input_channel: Optional[str] = None,
+    output_type: Optional[str] = None,
+    output_channel: Optional[str] = None,
 ) -> dict:
     """Set input/output routing for a track by display name. Use negative track_index for return tracks (-1=A, -2=B)."""
     _validate_track_index(track_index)

package/mcp_server/tools/notes.py

@@ -3,8 +3,10 @@
 8 tools matching the Remote Script notes domain.
 """
 
+from __future__ import annotations
+
 import json
-from typing import Any
+from typing import Any, Optional
 
 from fastmcp import Context
 

package/mcp_server/tools/tracks.py

@@ -3,6 +3,10 @@
 14 tools matching the Remote Script tracks domain.
 """
 
+from __future__ import annotations
+
+from typing import Optional
+
 from fastmcp import Context
 
 from ..server import mcp
@@ -34,8 +38,8 @@ def get_track_info(ctx: Context, track_index: int) -> dict:
 def create_midi_track(
     ctx: Context,
     index: int = -1,
-    name: str | None = None,
-    color: int | None = None,
+    name: Optional[str] = None,
+    color: Optional[int] = None,
 ) -> dict:
     """Create a new MIDI track. index=-1 appends at end."""
     params = {"index": index}
@@ -53,8 +57,8 @@ def create_midi_track(
 def create_audio_track(
     ctx: Context,
     index: int = -1,
-    name: str | None = None,
-    color: int | None = None,
+    name: Optional[str] = None,
+    color: Optional[int] = None,
 ) -> dict:
     """Create a new audio track. index=-1 appends at end."""
     params = {"index": index}

package/mcp_server/tools/transport.py

@@ -3,6 +3,10 @@
 12 tools matching the Remote Script transport domain.
 """
 
+from __future__ import annotations
+
+from typing import Optional
+
 from fastmcp import Context
 
 from ..server import mcp
@@ -68,8 +72,8 @@ def toggle_metronome(ctx: Context, enabled: bool) -> dict:
 def set_session_loop(
     ctx: Context,
     enabled: bool,
-    start: float | None = None,
-    length: float | None = None,
+    start: Optional[float] = None,
+    length: Optional[float] = None,
 ) -> dict:
     """Set loop on/off and optional loop region (start beat, length in beats)."""
     params = {"enabled": enabled}

package/package.json

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

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

@@ -17,6 +17,11 @@ 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)

package/plugin/commands/memory.md

@@ -0,0 +1,22 @@
+---
+name: memory
+description: Browse, search, and manage your saved technique library
+---
+
+Show the user's technique memory library. Follow these steps:
+
+1. Call `memory_list(limit=20)` to get an overview of saved techniques
+2. Format as an organized list grouped by type:
+   - **Beats** — beat_pattern techniques
+   - **Device Chains** — device_chain techniques
+   - **Mix Templates** — mix_template techniques
+   - **Browser Pins** — browser_pin techniques
+   - **Preferences** — preference techniques
+3. For each technique show: name, summary, rating (stars), favorite marker, tags
+4. Show total count and breakdown by type
+
+After presenting, ask if the user wants to:
+- **Search** — "search for [query]" → use memory_recall
+- **View details** — "show me [name]" → use memory_get
+- **Delete** — "delete [name]" → use memory_delete (confirm first)
+- **Rate** — "rate [name] 5 stars" → use memory_favorite

package/plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "livepilot",
-  "version": "1.3.0",
-  "description": "AI copilot for Ableton Live 12 — 96 MCP tools for music production, sound design, and mixing",
+  "version": "1.4.0",
+  "description": "AI copilot for Ableton Live 12 — 104 MCP tools for music production, sound design, and mixing",
   "author": "Pilot Studio",
   "skills": [
     "skills/livepilot-core"
@@ -10,7 +10,8 @@
     "commands/session.md",
     "commands/beat.md",
     "commands/mix.md",
-    "commands/sounddesign.md"
+    "commands/sounddesign.md",
+    "commands/memory.md"
   ],
   "agents": [
     "agents/livepilot-producer"

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

@@ -1,11 +1,11 @@
 ---
 name: livepilot-core
-description: Core discipline for controlling Ableton Live 12 through LivePilot's 96 MCP tools. Use whenever working with Ableton Live through MCP tools.
+description: Core discipline for controlling Ableton Live 12 through LivePilot's 104 MCP tools. Use whenever working with Ableton Live through MCP tools.
 ---
 
 # LivePilot Core — Ableton Live 12 AI Copilot
 
-LivePilot gives you 96 MCP tools to control Ableton Live 12 in real-time: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, and arrangement.
+LivePilot gives you 104 MCP tools to control Ableton Live 12 in real-time: transport, tracks, clips, MIDI notes, devices, scenes, mixing, browser, arrangement, and technique memory.
 
 ## Golden Rules
 
@@ -14,10 +14,11 @@ LivePilot gives you 96 MCP tools to control Ableton Live 12 in real-time: transp
 3. **Use `undo` liberally** — it's your safety net. Mention it to users when doing destructive ops
 4. **One operation at a time** — don't batch unrelated changes. Verify between steps
 5. **Track indices are 0-based** — track 0 is the first track. Use negative indices for return tracks (-1=A, -2=B). Use -1000 for master track.
-6. **Color indices 0-69** — Ableton's fixed palette. Don't guess — use the index
-7. **Volume is 0.0-1.0, pan is -1.0 to 1.0** — these are normalized, not dB
-8. **Tempo range 20-999 BPM** — validated before sending to Ableton
-9. **Always name your tracks and clips** — organization is part of the creative process
+6. **NEVER invent device/preset names** — always `search_browser` first, then use the exact `uri` from results with `load_browser_item`. Hallucinated names like "echomorph-hpf" will crash. The only exception is `find_and_load_device` for simple built-in effects ("Reverb", "Delay", "Compressor", "EQ Eight", "Saturator", "Utility").
+7. **Color indices 0-69** — Ableton's fixed palette. Don't guess — use the index
+8. **Volume is 0.0-1.0, pan is -1.0 to 1.0** — these are normalized, not dB
+9. **Tempo range 20-999 BPM** — validated before sending to Ableton
+10. **Always name your tracks and clips** — organization is part of the creative process
 
 ## Track Health Checks — MANDATORY
 
@@ -57,7 +58,7 @@ LivePilot gives you 96 MCP tools to control Ableton Live 12 in real-time: transp
 - MIDI track with no instrument loaded
 - Notes programmed but clip not fired
 
-## Tool Domains (96 total)
+## Tool Domains (104 total)
 
 ### Transport (12)
 `get_session_info` · `set_tempo` · `set_time_signature` · `start_playback` · `stop_playback` · `continue_playback` · `toggle_metronome` · `set_session_loop` · `undo` · `redo` · `get_recent_actions` · `get_session_diagnostics`
@@ -86,6 +87,9 @@ LivePilot gives you 96 MCP tools to control Ableton Live 12 in real-time: transp
 ### Arrangement (19)
 `get_arrangement_clips` · `create_arrangement_clip` · `add_arrangement_notes` · `get_arrangement_notes` · `remove_arrangement_notes` · `remove_arrangement_notes_by_id` · `modify_arrangement_notes` · `duplicate_arrangement_notes` · `transpose_arrangement_notes` · `set_arrangement_clip_name` · `set_arrangement_automation` · `back_to_arranger` · `jump_to_time` · `capture_midi` · `start_recording` · `stop_recording` · `get_cue_points` · `jump_to_cue` · `toggle_cue_point`
 
+### Memory (8)
+`memory_learn` · `memory_recall` · `memory_get` · `memory_replay` · `memory_list` · `memory_favorite` · `memory_update` · `memory_delete`
+
 ## Workflow: Building a Beat
 
 1. `get_session_info` — check current state
@@ -146,15 +150,59 @@ Use `remove_notes_by_id` for surgical deletion.
 Use `transpose_notes` for pitch shifting a region.
 Use `quantize_clip` to snap notes to a grid (grid is an enum: 1=1/4, 2=1/8, 5=1/16, 8=1/32).
 
+## Technique Memory
+
+LivePilot has a persistent memory system for saving and recalling techniques — beats, device chains, mixing setups, browser pins, and preferences — with rich stylistic analysis.
+
+### Three Modes of Operation
+
+**Informed (default):** Before creative decisions, consult memory:
+```
+memory_recall(query relevant to the task, limit=5)
+```
+Read the qualities of returned techniques. Let them INFLUENCE your choices — instrument selection, parameter ranges, rhythmic density, harmonic language — but always create something new. The memory shapes your understanding of this user's taste, not a template to copy.
+
+**Fresh (user override):** When the user signals a clean slate:
+- "ignore my history" / "something completely new" / "fresh"
+- "don't look at my saved stuff" / "surprise me"
+→ Skip memory_recall entirely. Use only the shipped corpus and your own musical knowledge.
+
+**Explicit Recall:** When the user references a saved technique:
+- "use that boom bap beat" / "load my lo-fi chain" / "remember that thing I saved?"
+→ `memory_recall` to find it → `memory_get` for full payload → `memory_replay` (adapt=false for exact, adapt=true for variation)
+
+### Saving Techniques
+
+When the user says "save this" / "remember this" / "I like this":
+
+1. Collect raw data using existing tools (get_notes, get_device_parameters, etc.)
+2. Write the qualities analysis — see `references/memory-guide.md` for the template
+3. Call `memory_learn` with type, qualities, payload, tags
+4. Confirm to the user what was saved and how it was characterized
+
+### Memory Tools (8)
+
+| Tool | What it does |
+|------|-------------|
+| `memory_learn` | Save a technique with qualities + payload |
+| `memory_recall` | Search by text query, type, tags — returns summaries |
+| `memory_get` | Fetch full technique by ID (with payload) |
+| `memory_replay` | Get replay plan for agent to execute |
+| `memory_list` | Browse library with filtering and sorting |
+| `memory_favorite` | Star and/or rate (0-5) a technique |
+| `memory_update` | Update name, tags, or qualities |
+| `memory_delete` | Remove (creates backup first) |
+
 ## Reference Corpus
 
 Deep production knowledge lives in `references/`. Consult these when making creative decisions — they contain specific parameter values, recipes, and patterns. Use them as starting points, not rigid rules.
 
 | File | What's inside | When to consult |
 |------|--------------|-----------------|
-| `references/overview.md` | All 96 tools mapped with params, units, ranges | Quick lookup for any tool |
+| `references/overview.md` | All 104 tools mapped with params, units, ranges | Quick lookup for any tool |
 | `references/midi-recipes.md` | Drum patterns by genre, chord voicings, scales, hi-hat techniques, humanization, polymetrics | Programming MIDI notes, building beats |
 | `references/sound-design.md` | Stock instruments/effects, parameter recipes for bass/pad/lead/pluck, device chain patterns | Loading and configuring devices |
 | `references/mixing-patterns.md` | Gain staging, parallel compression, sidechain, EQ by instrument, bus processing, stereo width | Setting volumes, panning, adding effects |
 | `references/ableton-workflow-patterns.md` | Session/Arrangement workflow, song structures by genre, follow actions, clip launch modes, export | Organizing sessions, structuring songs |
 | `references/m4l-devices.md` | Browser organization, MIDI effects, rack systems, device loading patterns | Finding and loading devices, using racks |
+| `references/memory-guide.md` | Qualities template, good/bad examples for each technique type | Saving techniques, writing qualities |

package/plugin/skills/livepilot-core/references/memory-guide.md

@@ -0,0 +1,107 @@
+# Technique Memory Guide — Qualities Template & Examples
+
+How to write rich, searchable stylistic analyses when saving techniques.
+
+## The Qualities Template
+
+Every technique gets an agent-written `qualities` object. All fields are optional
+except `summary` (required). Fill what's relevant to the technique type.
+
+| Field | What to write | Example |
+|-------|--------------|---------|
+| summary | One sentence — what this is and why it's good | "Dusty boom bap groove with lazy swing and ghost snares" |
+| mood | 2-4 mood/feeling words | ["laid-back", "dusty", "head-nodding"] |
+| genre_tags | Genre associations | ["boom-bap", "hip-hop", "lo-fi"] |
+| rhythm_feel | How the groove feels — swing, syncopation, density | "Syncopated kick with lazy hat swing, ghost snares anticipate the backbeat" |
+| harmonic_character | Key, scale, chord quality, movement | "C minor dorian, jazzy 7th chords, descending bass line" |
+| sonic_texture | Timbral character — warm/bright/gritty/clean | "Dusty vinyl-crackle hats, boomy 808 kick, dry snare with room verb" |
+| production_notes | When/how to use this, what it pairs with | "Works as verse beat, needs sparse melody on top — Rhodes or muted guitar" |
+| reference_points | Artists, songs, styles it evokes | "J Dilla 'Donuts' era meets Madlib 'Madvillainy' drums" |
+
+## Good vs Bad Qualities
+
+### Beat Pattern
+
+**GOOD:**
+```json
+{
+  "summary": "Dusty boom bap groove — lazy swing on the hats, ghost snares anticipate the backbeat, 85 BPM slow-roll energy",
+  "mood": ["laid-back", "dusty", "head-nodding"],
+  "genre_tags": ["boom-bap", "hip-hop"],
+  "rhythm_feel": "Syncopated kick at 0 and the 'and' of 1. Hi-hats on 8ths with +0.02 swing on offbeats. Ghost snares (vel 30) on 16ths before beats 2 and 4. The whole thing leans back.",
+  "production_notes": "Works as a verse beat. Needs sparse melody on top — Rhodes, muted guitar, or pitched sample. Leave headroom in low-mids for vocals.",
+  "reference_points": "J Dilla 'Donuts' era meets Madlib on 'Madvillainy'"
+}
+```
+
+**BAD:**
+```json
+{
+  "summary": "Hip hop beat at 85 BPM with kick, snare, and hi-hats"
+}
+```
+The bad version is factual but tells the agent nothing about *feel*. It can't distinguish this from any other hip-hop beat.
+
+### Device Chain
+
+**GOOD:**
+```json
+{
+  "summary": "Warm tape-style lo-fi chain — subtle saturation into gentle filtering, makes anything sound like it's playing through a dusty speaker",
+  "mood": ["warm", "nostalgic", "lo-fi"],
+  "sonic_texture": "Soft Sine saturation adds even harmonics without harshness. Auto Filter rolls off highs gently around 3kHz. Erosion adds subtle digital artifacts like worn tape. The chain darkens and warms without killing presence.",
+  "production_notes": "Put this on Rhodes, guitar samples, or pads. Not great for drums — kills transients. Works beautifully on chord progressions.",
+  "reference_points": "Lo-fi hip-hop study beats aesthetic, Nujabes-style warmth"
+}
+```
+
+**BAD:**
+```json
+{
+  "summary": "Saturator then Auto Filter then Erosion"
+}
+```
+
+### Mix Template
+
+**GOOD:**
+```json
+{
+  "summary": "Deep house return setup — long lush reverb on A, filtered ping-pong delay on B, subtle parallel compression on C",
+  "mood": ["spacious", "deep", "hypnotic"],
+  "genre_tags": ["deep-house", "tech-house"],
+  "sonic_texture": "Reverb is dark and long (4s decay, heavy high-cut) for depth without brightness. Delay is filtered (LP at 3kHz) so echoes sit behind the mix. Parallel compression adds density to drums without crushing transients.",
+  "production_notes": "Send drums to C at 0.3, pads to A at 0.5, synth stabs to B at 0.3. Keep kick dry (no sends). Return levels around -8dB for subtlety."
+}
+```
+
+### Preference
+
+**GOOD:**
+```json
+{
+  "summary": "Always use Valhalla VintageVerb instead of stock Reverb on return tracks — stock Reverb sounds too metallic in the highs for my taste"
+}
+```
+
+### Browser Pin
+
+**GOOD:**
+```json
+{
+  "summary": "808 Core Kit — my go-to drum kit for trap and hip-hop. Has a punchy kick that sits well with Saturator, crispy hats, and a tight clap."
+}
+```
+
+## When to Save
+
+- User says "save this" / "remember this" / "I like this"
+- A beat, sound, or chain turns out particularly well
+- User discovers a browser item they want to use again
+- User states a preference about how they work
+
+## When NOT to Save
+
+- Generic, unfinished, or placeholder work
+- Things that are already in the shipped reference corpus
+- Exact duplicates of existing saved techniques

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

@@ -1,6 +1,6 @@
 # LivePilot Architecture & Tool Reference
 
-LivePilot is an MCP server that controls Ableton Live 12 in real-time through 96 tools across 9 domains. This document maps every tool to what it actually does in Ableton, so you know exactly which tool to reach for.
+LivePilot is an MCP server that controls Ableton Live 12 in real-time through 104 tools across 10 domains. This document maps every tool to what it actually does in Ableton, so you know exactly which tool to reach for.
 
 ## Architecture
 
@@ -14,7 +14,7 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 - **Protocol**: JSON over TCP, newline-delimited. Every command gets a response.
 - **Thread safety**: All Live Object Model (LOM) access happens on Ableton's main thread
 
-## The 96 Tools — What Each One Does
+## The 104 Tools — What Each One Does
 
 ### Transport (12) — Playback, tempo, global state, diagnostics
 
@@ -142,7 +142,7 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `get_browser_tree` | Returns top-level browser categories | — |
 | `get_browser_items` | Lists items in a browser path | `path` |
 | `search_browser` | Searches the browser | `query` |
-| `load_browser_item` | Loads a browser item onto a track | `track_index`, `uri` |
+| `load_browser_item` | Loads a browser item onto a track — **`uri` MUST come from `search_browser` results, NEVER invented** | `track_index`, `uri` |
 
 ### Arrangement (19) — Timeline, recording, cue points, arrangement notes
 
@@ -168,6 +168,19 @@ Claude Code  ──MCP──►  FastMCP Server  ──TCP/9878──►  Remote
 | `jump_to_cue` | Jumps to a cue point by index | `cue_index` |
 | `toggle_cue_point` | Creates/removes cue point at current position | — |
 
+### Memory (8) — Technique library persistence
+
+| Tool | What it does | Key params |
+|------|-------------|------------|
+| `memory_learn` | Saves a technique with stylistic qualities | `name`, `type`, `qualities`, `payload`, `tags` |
+| `memory_recall` | Searches library by text and filters | `query`, `type`, `tags`, `limit` |
+| `memory_get` | Fetches full technique including payload | `technique_id` |
+| `memory_replay` | Returns technique with replay plan for agent | `technique_id`, `adapt` (bool) |
+| `memory_list` | Browses library with filtering/sorting | `type`, `tags`, `sort_by`, `limit` |
+| `memory_favorite` | Stars and/or rates a technique | `technique_id`, `favorite`, `rating` (0-5) |
+| `memory_update` | Updates name, tags, or qualities | `technique_id`, `name`, `tags`, `qualities` |
+| `memory_delete` | Removes technique (backs up first) | `technique_id` |
+
 ## Units & Ranges Quick Reference
 
 | Concept | Unit/Range | Notes |