livepilot 1.9.23 → 1.10.0

package/mcp_server/device_forge/templates.py

@@ -0,0 +1,483 @@
+"""gen~ DSP building block library — GenExpr code as reusable templates.
+
+Each template is a complete, working gen~ codebox program with parameters.
+Templates are organized by category and can be used directly with
+generate_m4l_effect or as starting points for custom devices.
+"""
+
+from __future__ import annotations
+
+from .models import GenExprParam, GenExprTemplate, UNIT_STYLE_HERTZ, UNIT_STYLE_PERCENT, UNIT_STYLE_FLOAT
+
+TEMPLATES: dict[str, GenExprTemplate] = {}
+
+
+def _register(t: GenExprTemplate) -> GenExprTemplate:
+    TEMPLATES[t.template_id] = t
+    return t
+
+
+def get_template(template_id: str) -> GenExprTemplate | None:
+    return TEMPLATES.get(template_id)
+
+
+def list_templates(category: str = "") -> list[dict]:
+    items = list(TEMPLATES.values())
+    if category:
+        items = [t for t in items if t.category == category]
+    return [t.to_dict() for t in items]
+
+
+def list_categories() -> list[str]:
+    return sorted({t.category for t in TEMPLATES.values()})
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# UTILITY
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="passthrough",
+    name="Passthrough",
+    description="Clean audio passthrough — useful as a starting skeleton",
+    category="utility",
+    code="out1 = in1;",
+    params=[],
+))
+
+# ═══════════════════════════════════════════════════════════════════════
+# CHAOS
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="lorenz_attractor",
+    name="Lorenz Attractor",
+    description="Three coupled differential equations producing chaotic modulation. "
+                "Smooth but unpredictable — great for filter cutoff, pan, and send modulation.",
+    category="chaos",
+    code="""\
+Param sigma(10);
+Param rho(28);
+Param beta(2.667);
+Param speed(0.001);
+
+History x(0.1);
+History y(0);
+History z(0);
+
+dx = sigma * (y - x);
+dy = x * (rho - z) - y;
+dz = x * y - beta * z;
+
+x += dx * speed;
+y += dy * speed;
+z += dz * speed;
+
+out1 = x * 0.02;""",
+    params=[
+        GenExprParam(name="sigma", default=10, min_val=0.1, max_val=50),
+        GenExprParam(name="rho", default=28, min_val=0.1, max_val=100),
+        GenExprParam(name="beta", default=2.667, min_val=0.1, max_val=10),
+        GenExprParam(name="speed", default=0.001, min_val=0.0001, max_val=0.01),
+    ],
+))
+
+_register(GenExprTemplate(
+    template_id="henon_map",
+    name="Henon Map",
+    description="Discrete chaotic map — produces noise textures at some parameters, "
+                "pitched tones at others. The edge-of-chaos zone is musically rich.",
+    category="chaos",
+    code="""\
+Param a(1.4);
+Param b(0.3);
+Param speed(0.01);
+
+History x(0.1);
+History y(0);
+
+nx = 1 - a * x * x + y;
+ny = b * x;
+
+x = nx;
+y = ny;
+
+out1 = x * speed;""",
+    params=[
+        GenExprParam(name="a", default=1.4, min_val=0.1, max_val=2.0),
+        GenExprParam(name="b", default=0.3, min_val=0.0, max_val=1.0),
+        GenExprParam(name="speed", default=0.01, min_val=0.001, max_val=0.1),
+    ],
+))
+
+# ═══════════════════════════════════════════════════════════════════════
+# SYNTHESIS
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="karplus_strong",
+    name="Karplus-Strong String",
+    description="Plucked string physical model — noise burst excitation through "
+                "a filtered delay line. Classic digital waveguide synthesis.",
+    category="synthesis",
+    code="""\
+Param freq(220);
+Param damping(0.996);
+Param brightness(0.5);
+
+delaySamples = samplerate / max(freq, 20);
+History h1(0);
+
+trigger = in1 > 0.5;
+excitation = noise() * trigger;
+
+delayed = delay(h1, delaySamples);
+filtered = delayed * brightness + h1 * (1 - brightness);
+h1 = excitation + filtered * damping;
+
+out1 = h1;""",
+    params=[
+        GenExprParam(name="freq", default=220, min_val=20, max_val=20000, unit_style=UNIT_STYLE_HERTZ),
+        GenExprParam(name="damping", default=0.996, min_val=0.9, max_val=0.9999),
+        GenExprParam(name="brightness", default=0.5, min_val=0.0, max_val=1.0),
+    ],
+))
+
+_register(GenExprTemplate(
+    template_id="karplus_strong_reverb",
+    name="Karplus-Strong with Reverb Feedback",
+    description="KS variant with allpass diffusion in the feedback loop instead of simple "
+                "lowpass. Produces sustained, evolving, richly harmonic tones.",
+    category="synthesis",
+    code="""\
+Param freq(220);
+Param damping(0.995);
+Param diffusion(0.5);
+
+delaySamples = samplerate / max(freq, 20);
+History h1(0);
+History ap1(0);
+History ap2(0);
+
+trigger = in1 > 0.5;
+excitation = noise() * trigger;
+
+delayed = delay(h1, delaySamples);
+
+// Two allpass stages for diffusion
+ap1_in = delayed + ap1 * diffusion;
+ap1_out = ap1 * -diffusion + delay(ap1_in, 37);
+ap1 = ap1_in;
+
+ap2_in = ap1_out + ap2 * diffusion;
+ap2_out = ap2 * -diffusion + delay(ap2_in, 113);
+ap2 = ap2_in;
+
+filtered = (ap2_out + delayed) * 0.5;
+h1 = excitation + filtered * damping;
+
+out1 = h1;""",
+    params=[
+        GenExprParam(name="freq", default=220, min_val=20, max_val=20000, unit_style=UNIT_STYLE_HERTZ),
+        GenExprParam(name="damping", default=0.995, min_val=0.9, max_val=0.9999),
+        GenExprParam(name="diffusion", default=0.5, min_val=0.0, max_val=0.9),
+    ],
+))
+
+_register(GenExprTemplate(
+    template_id="phase_distortion",
+    name="Phase Distortion Synth",
+    description="CZ-style phase distortion synthesis — a phasor's shape is warped "
+                "before reading a cosine table, creating rich timbral evolution.",
+    category="synthesis",
+    code="""\
+Param freq(440);
+Param distortion(0.5);
+
+History phase(0);
+
+phase += freq / samplerate;
+phase = wrap(phase, 0, 1);
+
+// Distort the phase curve
+warped = phase + distortion * sin(phase * TWOPI) * 0.5;
+warped = wrap(warped, 0, 1);
+
+out1 = cos(warped * TWOPI) * 0.5;""",
+    params=[
+        GenExprParam(name="freq", default=440, min_val=20, max_val=20000, unit_style=UNIT_STYLE_HERTZ),
+        GenExprParam(name="distortion", default=0.5, min_val=0.0, max_val=1.0),
+    ],
+))
+
+# ═══════════════════════════════════════════════════════════════════════
+# DISTORTION
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="wavefolder",
+    name="Wavefolder",
+    description="Buchla-style wavefolder — folds the waveform back on itself, "
+                "generating rich harmonic series. Multiple fold stages for complexity.",
+    category="distortion",
+    code="""\
+Param drive(2);
+Param symmetry(0.5);
+Param mix(0.75);
+
+input = in1 * drive;
+
+// Three fold stages
+folded = fold(input + symmetry - 0.5, -1, 1);
+folded = fold(folded * 1.5, -1, 1);
+folded = fold(folded * 1.2, -1, 1);
+
+out1 = in1 * (1 - mix) + folded * mix;""",
+    params=[
+        GenExprParam(name="drive", default=2, min_val=1, max_val=20),
+        GenExprParam(name="symmetry", default=0.5, min_val=0.0, max_val=1.0),
+        GenExprParam(name="mix", default=0.75, min_val=0.0, max_val=1.0, unit_style=UNIT_STYLE_PERCENT),
+    ],
+))
+
+_register(GenExprTemplate(
+    template_id="bitcrusher",
+    name="Bitcrusher",
+    description="Sample-rate and bit-depth reducer — from subtle aliasing to full "
+                "digital destruction. Modulate rate for glitch textures.",
+    category="distortion",
+    code="""\
+Param rate(0.5);
+Param bits(8);
+
+// Sample rate reduction via sample-and-hold
+reduced = latch(in1, phasor(samplerate * max(rate, 0.01)));
+
+// Bit depth reduction
+levels = pow(2, max(bits, 1));
+crushed = floor(reduced * levels + 0.5) / levels;
+
+out1 = crushed;""",
+    params=[
+        GenExprParam(name="rate", default=0.5, min_val=0.01, max_val=1.0),
+        GenExprParam(name="bits", default=8, min_val=1, max_val=16),
+    ],
+))
+
+# ═══════════════════════════════════════════════════════════════════════
+# MODULATION
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="ring_modulator",
+    name="Ring Modulator",
+    description="Classic ring modulation — input multiplied by a carrier oscillator. "
+                "Use sub-audio rates for tremolo, audio rates for metallic sidebands.",
+    category="modulation",
+    code="""\
+Param freq(100);
+Param depth(1.0);
+Param mix(0.5);
+
+carrier = cycle(freq);
+modulated = in1 * (1 - depth + depth * carrier);
+
+out1 = in1 * (1 - mix) + modulated * mix;""",
+    params=[
+        GenExprParam(name="freq", default=100, min_val=0.1, max_val=20000, unit_style=UNIT_STYLE_HERTZ),
+        GenExprParam(name="depth", default=1.0, min_val=0.0, max_val=1.0),
+        GenExprParam(name="mix", default=0.5, min_val=0.0, max_val=1.0, unit_style=UNIT_STYLE_PERCENT),
+    ],
+))
+
+_register(GenExprTemplate(
+    template_id="chorus",
+    name="Chorus",
+    description="Multi-voice micro-delay chorus — three slightly detuned delay taps "
+                "create width and shimmer without muddiness.",
+    category="modulation",
+    code="""\
+Param rate(0.5);
+Param depth(0.003);
+Param mix(0.5);
+
+base_delay = 0.01 * samplerate;
+mod1 = cycle(rate) * depth * samplerate;
+mod2 = cycle(rate * 1.1) * depth * samplerate * 0.8;
+mod3 = cycle(rate * 0.9) * depth * samplerate * 1.2;
+
+d1 = delay(in1, base_delay + mod1);
+d2 = delay(in1, base_delay + mod2);
+d3 = delay(in1, base_delay + mod3);
+
+wet = (d1 + d2 + d3) / 3;
+
+out1 = in1 * (1 - mix) + wet * mix;""",
+    params=[
+        GenExprParam(name="rate", default=0.5, min_val=0.05, max_val=5, unit_style=UNIT_STYLE_HERTZ),
+        GenExprParam(name="depth", default=0.003, min_val=0.0, max_val=0.02),
+        GenExprParam(name="mix", default=0.5, min_val=0.0, max_val=1.0, unit_style=UNIT_STYLE_PERCENT),
+    ],
+))
+
+# ═══════════════════════════════════════════════════════════════════════
+# DELAY
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="feedback_delay",
+    name="Feedback Delay",
+    description="Simple delay line with filtered feedback — the backbone of "
+                "echo effects, dub delays, and ambient washes.",
+    category="delay",
+    code="""\
+Param time(0.25);
+Param feedback(0.5);
+Param damping(0.7);
+
+History prev_out(0);
+
+delay_samples = max(time, 0.001) * samplerate;
+delayed = delay(in1 + prev_out * feedback, delay_samples);
+
+// One-pole lowpass in feedback path
+filtered = delayed * damping + prev_out * (1 - damping);
+prev_out = filtered;
+
+out1 = in1 * 0.5 + filtered * 0.5;""",
+    params=[
+        GenExprParam(name="time", default=0.25, min_val=0.001, max_val=2.0),
+        GenExprParam(name="feedback", default=0.5, min_val=0.0, max_val=0.95),
+        GenExprParam(name="damping", default=0.7, min_val=0.0, max_val=1.0),
+    ],
+))
+
+_register(GenExprTemplate(
+    template_id="feedback_delay_network",
+    name="Feedback Delay Network",
+    description="4-line FDN with Hadamard-like cross-coupling matrix. Creates dense, "
+                "diffuse reverb tails. Tune delay times to musical intervals for harmonic reverb.",
+    category="delay",
+    code="""\
+Param size(0.05);
+Param feedback(0.7);
+Param damping(0.8);
+
+History a(0);
+History b(0);
+History c(0);
+History d(0);
+
+base = max(size, 0.001) * samplerate;
+da = delay(a, base * 1.0);
+db = delay(b, base * 1.347);
+dc = delay(c, base * 1.573);
+dd = delay(d, base * 1.811);
+
+// Hadamard-like mixing matrix (preserves energy)
+na = ( da + db + dc + dd) * 0.5;
+nb = ( da - db + dc - dd) * 0.5;
+nc = ( da + db - dc - dd) * 0.5;
+nd = ( da - db - dc + dd) * 0.5;
+
+// Damping + feedback + input injection
+a = (na * damping) * feedback + in1;
+b = (nb * damping) * feedback;
+c = (nc * damping) * feedback;
+d = (nd * damping) * feedback;
+
+out1 = (da + db + dc + dd) * 0.25;""",
+    params=[
+        GenExprParam(name="size", default=0.05, min_val=0.001, max_val=0.5),
+        GenExprParam(name="feedback", default=0.7, min_val=0.0, max_val=0.95),
+        GenExprParam(name="damping", default=0.8, min_val=0.0, max_val=1.0),
+    ],
+))
+
+_register(GenExprTemplate(
+    template_id="granular_delay",
+    name="Granular Delay",
+    description="Buffer-based granular delay — reads from a circular delay buffer "
+                "at variable positions and grain sizes for textural delays.",
+    category="delay",
+    code="""\
+Param position(0.5);
+Param grain_size(0.05);
+Param density(10);
+Param mix(0.5);
+
+grain_phase = phasor(density);
+window = sin(grain_phase * 3.14159);
+
+delay_samples = position * samplerate;
+grain_samples = max(grain_size, 0.001) * samplerate;
+read_pos = delay_samples + grain_phase * grain_samples;
+
+wet = delay(in1, max(read_pos, 1)) * window;
+
+out1 = in1 * (1 - mix) + wet * mix;""",
+    params=[
+        GenExprParam(name="position", default=0.5, min_val=0.0, max_val=2.0),
+        GenExprParam(name="grain_size", default=0.05, min_val=0.001, max_val=0.5),
+        GenExprParam(name="density", default=10, min_val=1, max_val=100),
+        GenExprParam(name="mix", default=0.5, min_val=0.0, max_val=1.0, unit_style=UNIT_STYLE_PERCENT),
+    ],
+))
+
+# ═══════════════════════════════════════════════════════════════════════
+# FILTER
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="resonator",
+    name="Comb Resonator",
+    description="Tuned comb filter that resonates at a specific frequency — "
+                "feed it noise for metallic tones, or audio for pitched resonance.",
+    category="filter",
+    code="""\
+Param freq(440);
+Param resonance(0.9);
+Param mix(0.5);
+
+History fb(0);
+
+delay_samples = samplerate / max(freq, 20);
+delayed = delay(fb, delay_samples);
+fb = in1 + delayed * min(resonance, 0.999);
+
+out1 = in1 * (1 - mix) + fb * mix;""",
+    params=[
+        GenExprParam(name="freq", default=440, min_val=20, max_val=20000, unit_style=UNIT_STYLE_HERTZ),
+        GenExprParam(name="resonance", default=0.9, min_val=0.0, max_val=0.999),
+        GenExprParam(name="mix", default=0.5, min_val=0.0, max_val=1.0, unit_style=UNIT_STYLE_PERCENT),
+    ],
+))
+
+# ═══════════════════════════════════════════════════════════════════════
+# TEXTURE
+# ═══════════════════════════════════════════════════════════════════════
+
+_register(GenExprTemplate(
+    template_id="stochastic_resonance",
+    name="Stochastic Resonance",
+    description="Noise + threshold + feedback system — adding controlled noise to a "
+                "nonlinear threshold creates granular textures and organic movement.",
+    category="texture",
+    code="""\
+Param threshold(0.3);
+Param noise_amount(0.2);
+Param feedback(0.5);
+
+History state(0);
+
+noisy = in1 + noise() * noise_amount + state * feedback;
+triggered = noisy > threshold;
+state = triggered * 0.8 + state * 0.2;
+
+out1 = (triggered * 2 - 1) * 0.5;""",
+    params=[
+        GenExprParam(name="threshold", default=0.3, min_val=0.0, max_val=1.0),
+        GenExprParam(name="noise_amount", default=0.2, min_val=0.0, max_val=1.0),
+        GenExprParam(name="feedback", default=0.5, min_val=0.0, max_val=0.95),
+    ],
+))

package/mcp_server/device_forge/tools.py

@@ -0,0 +1,162 @@
+"""Device Forge MCP tools — generate M4L devices from gen~ code.
+
+3 tools for the device_forge domain.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from pathlib import Path
+
+from fastmcp import Context
+
+from ..server import mcp
+from .models import DeviceSpec, DeviceType, GenExprParam
+from .builder import build_device, ABLETON_USER_LIBRARY, _SUBDIR_MAP
+from .templates import get_template, list_templates, list_categories
+
+
+@mcp.tool()
+async def generate_m4l_effect(
+    ctx: Context,
+    name: str,
+    gen_code: str,
+    description: str = "Generated by LivePilot Device Forge",
+    device_type: str = "audio_effect",
+    params: list[dict] | None = None,
+    install: bool = True,
+) -> dict:
+    """Generate a Max for Live device from gen~ codebox code.
+
+    The gen_code parameter accepts GenExpr DSP code that will be compiled
+    at runtime by Max's gen~ engine. Safety clipping is automatically added.
+
+    Args:
+        name: Device name (used for filename and display)
+        gen_code: GenExpr source code for the gen~ codebox
+        description: Device description
+        device_type: "audio_effect", "midi_effect", "instrument", "midi_generator", or "midi_transformation"
+        params: List of parameter dicts with keys: name, default, min_val, max_val, unit_style
+        install: If True, copy to Ableton User Library automatically
+    """
+    type_map = {
+        "audio_effect": DeviceType.AUDIO_EFFECT,
+        "midi_effect": DeviceType.MIDI_EFFECT,
+        "instrument": DeviceType.INSTRUMENT,
+        "midi_generator": DeviceType.MIDI_GENERATOR,
+        "midi_transformation": DeviceType.MIDI_TRANSFORMATION,
+    }
+    dt = type_map.get(device_type)
+    if dt is None:
+        return {"error": f"Invalid device_type: {device_type}. Use: audio_effect, midi_effect, instrument"}
+
+    parsed_params = []
+    if params:
+        for p in params:
+            parsed_params.append(GenExprParam(
+                name=p["name"],
+                default=p.get("default", 0.5),
+                min_val=p.get("min_val", 0.0),
+                max_val=p.get("max_val", 1.0),
+                unit_style=p.get("unit_style", 1),
+            ))
+
+    spec = DeviceSpec(
+        name=name,
+        device_type=dt,
+        gen_code=gen_code,
+        description=description,
+        params=parsed_params,
+    )
+
+    if install:
+        subdir = _SUBDIR_MAP[dt]
+        output_dir = ABLETON_USER_LIBRARY / subdir
+        path = build_device(spec, output_dir=output_dir)
+    else:
+        path = build_device(spec, output_dir=tempfile.mkdtemp(prefix="livepilot_forge_"))
+
+    return {
+        "status": "created",
+        "name": spec.name,
+        "filename": spec.safe_filename,
+        "path": str(path),
+        "device_type": device_type,
+        "installed": install,
+        "param_count": len(parsed_params),
+        "hint": "Device will appear in Ableton's browser. Use find_and_load_device to load it onto a track.",
+    }
+
+
+@mcp.tool()
+async def list_genexpr_templates(
+    ctx: Context,
+    category: str = "",
+) -> dict:
+    """List available gen~ DSP building block templates.
+
+    Templates are pre-built GenExpr algorithms that can be used directly
+    or as starting points for custom devices. Each template has working
+    code, parameters, and descriptions.
+
+    Args:
+        category: Filter by category (chaos, delay, distortion, filter, modulation, synthesis, texture, utility). Empty = all.
+    """
+    templates = list_templates(category=category)
+    categories = list_categories()
+
+    return {
+        "templates": templates,
+        "count": len(templates),
+        "categories": sorted(categories),
+        "hint": "Use generate_m4l_effect with a template's code to create a device, or write custom GenExpr.",
+    }
+
+
+@mcp.tool()
+async def install_m4l_device(
+    ctx: Context,
+    source_path: str,
+) -> dict:
+    """Copy a .amxd file to Ableton's User Library.
+
+    Args:
+        source_path: Path to the .amxd file to install
+    """
+    src = Path(source_path)
+    if not src.exists():
+        return {"error": f"File not found: {source_path}"}
+    if src.suffix != ".amxd":
+        return {"error": f"Not an .amxd file: {source_path}"}
+
+    data = src.read_bytes()
+    if len(data) < 12 or data[:4] != b"ampf":
+        return {"error": "Invalid .amxd file — missing ampf header"}
+
+    marker = data[8:12]
+    type_map = {
+        b"aaaa": (DeviceType.AUDIO_EFFECT, "audio_effect"),
+        b"mmmm": (DeviceType.MIDI_EFFECT, "midi_effect"),
+        b"iiii": (DeviceType.INSTRUMENT, "instrument"),
+        b"nagg": (DeviceType.MIDI_GENERATOR, "midi_generator"),
+        b"natt": (DeviceType.MIDI_TRANSFORMATION, "midi_transformation"),
+    }
+    dt_info = type_map.get(marker)
+    if dt_info is None:
+        return {"error": f"Unknown device type marker: {marker}"}
+
+    dt, type_name = dt_info
+    subdir = _SUBDIR_MAP[dt]
+    dest_dir = ABLETON_USER_LIBRARY / subdir
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    dest = dest_dir / src.name
+    dest.write_bytes(data)
+
+    return {
+        "status": "installed",
+        "filename": src.name,
+        "device_type": type_name,
+        "path": str(dest),
+        "hint": "Device now available in Ableton's browser.",
+    }

package/mcp_server/hook_hunter/analyzer.py

@@ -82,9 +82,32 @@ def find_hook_candidates(
                 development_potential=0.5,
             ))
 
+    # 4. Section-placement analysis: boost hooks that appear in payoff sections
+    payoff_sections = {
+        s.get("label", "").lower()
+        for s in (composition.get("sections", []) if composition else [])
+        if s.get("is_payoff")
+    } or {"chorus", "drop", "hook"}
+
+    for c in candidates:
+        # Check if hook is present in payoff sections (via motif locations)
+        if c.hook_type == "melodic" and motif_data:
+            for motif in motif_data.get("motifs", []):
+                if motif.get("name", "") in c.hook_id:
+                    # Motif with high recurrence across sections = stronger hook
+                    c.memorability = min(1.0, c.memorability + motif.get("recurrence", 0) * 0.2)
+
     # Score all candidates
     for c in candidates:
         c.salience = _compute_salience(c)
+        # Add evidence sources
+        c.evidence_sources = []
+        if "motif_" in c.hook_id:
+            c.evidence_sources.append("motif_recurrence")
+        if "track_" in c.hook_id:
+            c.evidence_sources.append("track_name")
+        if "groove" in c.hook_id:
+            c.evidence_sources.append("clip_reuse")
 
     # Sort by salience
     candidates.sort(key=lambda c: c.salience, reverse=True)

package/mcp_server/hook_hunter/models.py

@@ -19,6 +19,7 @@ class HookCandidate:
     contrast_potential: float = 0.0  # 0-1 how well it stands out
     development_potential: float = 0.0  # 0-1 how much room to develop
     salience: float = 0.0  # composite score
+    evidence_sources: list[str] = field(default_factory=list)  # what data informed this
 
     def to_dict(self) -> dict:
         return asdict(self)

package/mcp_server/hook_hunter/tools.py

@@ -53,9 +53,11 @@ def _fetch_tracks_and_scenes(ctx: Context) -> tuple[list[dict], list[dict], dict
     except Exception:
         pass
 
-    # Fetch motif data from the motif engine for salience-based hook discovery
+    # Fetch motif data — via shared motif service
     try:
-        motif_data = ableton.send_command("get_motif_graph")
+        from ..services.motif_service import get_motif_data, fetch_notes_from_ableton
+        notes_by_track = fetch_notes_from_ableton(ableton, tracks)
+        motif_data = get_motif_data(notes_by_track)
     except Exception:
         pass  # Motif graph requires notes in clips; empty dict is valid fallback