livepilot 1.12.2 → 1.14.0

package/mcp_server/wonder_mode/engine.py

@@ -3,6 +3,13 @@
 Generates contextually different creative variants ranked by
 taste, identity, and coherence. Each variant is built from a
 real semantic move matched to the request.
+
+PR6 adds a branch-native assembly path (generate_branch_seeds) that emits
+BranchSeed objects from multiple producers — semantic_move, technique
+memory, sacred-element inversion, and corpus-hint freeform seeds. The
+existing generate_wonder_variants path is untouched; callers that speak
+BranchSeed can consume the new function, callers that speak "variants"
+keep the old one.
 """
 
 from __future__ import annotations
@@ -13,6 +20,8 @@ import logging
 import math
 from typing import Optional
 
+from ..branches import BranchSeed, seed_from_move_id, freeform_seed
+
 logger = logging.getLogger(__name__)
 
 
@@ -626,3 +635,318 @@ def _wonder_id(request_text: str, kernel_id: str) -> str:
     """Deterministic variant ID prefix — no timestamp."""
     seed = json.dumps({"r": request_text, "k": kernel_id}, sort_keys=True)
     return "wm_" + hashlib.sha256(seed.encode()).hexdigest()[:10]
+
+
+# ── PR6 — branch-native seed assembly ────────────────────────────────────
+
+
+def _stable_seed_short_id(prefix: str, key: str) -> str:
+    """Deterministic short id for a seed, no timestamp."""
+    h = hashlib.sha256(f"{prefix}:{key}".encode()).hexdigest()[:10]
+    return f"{prefix}_{h}"
+
+
+_MOVE_NOVELTY_BY_INDEX = ("safe", "strong", "unexpected")
+
+
+def generate_branch_seeds(
+    request_text: str,
+    kernel: Optional[dict] = None,
+    song_brain: Optional[dict] = None,
+    active_constraints: object = None,
+    taste_graph: object = None,
+    max_seeds: int = 3,
+) -> list[BranchSeed]:
+    """Assemble BranchSeeds from multiple creative sources.
+
+    Branch-native companion to ``generate_wonder_variants``. Instead of
+    returning pre-built variant dicts tied to moves, emits BranchSeed
+    objects that can be fed to ``create_experiment_from_seeds`` or
+    ``create_experiment(seeds=[...])`` directly.
+
+    Sources (assembled in this order until max_seeds is reached):
+
+      1. ``semantic_move`` — one seed per distinct move discovered by
+         ``discover_moves`` + ``select_distinct_variants``. Novelty tier
+         is assigned positionally: first move = safe, second = strong,
+         third = unexpected.
+
+      2. ``technique`` — freeform seeds built from kernel.session_memory
+         entries whose category is "technique" or "success". Low-novelty
+         by design (known-good).
+
+      3. sacred-element inversion — freeform seeds that deliberately
+         contrast a sacred element from ``song_brain.sacred_elements``.
+         Only emitted when kernel.freshness >= 0.5. High-novelty,
+         high-risk. These seeds are typically analytical until a
+         producer (Wonder itself or synthesis_brain) compiles them.
+
+      4. corpus hints — freeform seeds built from ``_get_corpus_hints``.
+         Medium novelty, grounded in the corpus knowledge base.
+
+    Distinctness rules:
+      - At most one seed with each exact hypothesis (case-insensitive)
+      - semantic_move seeds already pass through select_distinct_variants
+        so their (family, plan_shape) distinctness is preserved
+
+    When kernel is None, the function still works — it just skips the
+    kernel-driven sources (technique memory, freshness-gated inversion).
+
+    Does NOT include synthesis or composer seeds — those emit
+    (seed, compiled_plan) pairs and must be handled by callers that
+    can thread plans through. Use generate_branch_seeds_and_plans() for
+    the full multi-producer assembly.
+    """
+    kernel = kernel or {}
+    song_brain = song_brain or {}
+    seeds: list[BranchSeed] = []
+    used_hypotheses: set[str] = set()
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+
+    # ── 1. semantic_move seeds ────────────────────────────────────────
+    moves = discover_moves(
+        request_text,
+        taste_graph=taste_graph,
+        active_constraints=active_constraints,
+    )
+    distinct_moves = select_distinct_variants(moves)
+
+    for i, move in enumerate(distinct_moves):
+        if len(seeds) >= max_seeds:
+            return seeds
+        label = _MOVE_NOVELTY_BY_INDEX[i] if i < len(_MOVE_NOVELTY_BY_INDEX) else "strong"
+        hypothesis = move.get("intent") or f"Apply {move.get('move_id', '')}"
+        seed = seed_from_move_id(
+            move_id=move.get("move_id", ""),
+            hypothesis=hypothesis,
+            novelty_label=label,
+            risk_label=move.get("risk_level", "low"),
+            distinctness_reason=_explain_distinctness(move, distinct_moves, i),
+        )
+        seeds.append(seed)
+        used_hypotheses.add(hypothesis.lower())
+
+    # ── 2. technique seeds from session memory ────────────────────────
+    session_mem = kernel.get("session_memory") or []
+    for mem in session_mem:
+        if len(seeds) >= max_seeds:
+            return seeds
+        if mem.get("category") not in ("technique", "success"):
+            continue
+        content = (mem.get("content") or "").strip()
+        if not content:
+            continue
+        hyp = f"Replay: {content[:100]}"
+        if hyp.lower() in used_hypotheses:
+            continue
+        seed = freeform_seed(
+            seed_id=_stable_seed_short_id("tech", content),
+            hypothesis=hyp,
+            source="technique",
+            novelty_label="safe",
+            risk_label="low",
+            distinctness_reason="recalled from session memory — known to work",
+        )
+        seeds.append(seed)
+        used_hypotheses.add(hyp.lower())
+
+    # ── 3. sacred-element inversion (freshness-gated) ────────────────
+    if freshness >= 0.5:
+        sacred = song_brain.get("sacred_elements") or []
+        for s in sacred[:2]:
+            if len(seeds) >= max_seeds:
+                return seeds
+            elem_type = s.get("element_type", "element")
+            desc = s.get("description") or elem_type
+            hyp = f"What if we invert {desc}?"
+            if hyp.lower() in used_hypotheses:
+                continue
+            # Protect every OTHER sacred element — the point is to contrast
+            # one of them deliberately.
+            other_protected = [
+                other.get("element_type", "")
+                for other in sacred
+                if other.get("element_type") != elem_type
+            ]
+            seed = freeform_seed(
+                seed_id=_stable_seed_short_id("invert", elem_type),
+                hypothesis=hyp,
+                source="freeform",
+                novelty_label="unexpected",
+                risk_label="high",
+                protected_qualities=[p for p in other_protected if p],
+                distinctness_reason=(
+                    f"deliberately contrasts the '{desc}' that baseline "
+                    f"branches preserve"
+                ),
+            )
+            seeds.append(seed)
+            used_hypotheses.add(hyp.lower())
+
+    # ── 4. corpus-hint seeds ──────────────────────────────────────────
+    corpus_hints = _get_corpus_hints(request_text, song_brain.get("diagnosis"))
+    if corpus_hints:
+        for kind, hint in corpus_hints.items():
+            if len(seeds) >= max_seeds:
+                return seeds
+            if not isinstance(hint, dict):
+                continue
+            if kind == "emotional_recipe":
+                hyp = (
+                    f"Apply {hint.get('emotion', 'emotional')} recipe "
+                    f"({hint.get('technique_count', 0)} techniques)"
+                )
+            elif kind == "genre_chain":
+                devices = hint.get("devices", []) or []
+                hyp = (
+                    f"Build {hint.get('genre', 'genre')} chain: "
+                    f"{', '.join(devices[:3])}"
+                )
+            elif kind == "physical_model":
+                devices = hint.get("devices", []) or []
+                hyp = (
+                    f"Model {hint.get('material', 'material')} via "
+                    f"{', '.join(devices[:3])}"
+                )
+            else:
+                continue
+
+            if hyp.lower() in used_hypotheses:
+                continue
+            seed = freeform_seed(
+                seed_id=_stable_seed_short_id("corpus", f"{kind}:{hyp}"),
+                hypothesis=hyp,
+                source="freeform",
+                novelty_label="strong",
+                risk_label="medium",
+                distinctness_reason=f"corpus-grounded {kind.replace('_', ' ')}",
+            )
+            seeds.append(seed)
+            used_hypotheses.add(hyp.lower())
+
+    return seeds
+
+
+def generate_branch_seeds_and_plans(
+    request_text: str,
+    kernel: Optional[dict] = None,
+    song_brain: Optional[dict] = None,
+    active_constraints: object = None,
+    taste_graph: object = None,
+    max_seeds: int = 3,
+    synth_profiles: Optional[list] = None,
+    composer_request: Optional[str] = None,
+    composer_count: int = 2,
+) -> tuple[list[BranchSeed], dict[str, dict]]:
+    """Full multi-producer branch assembly with pre-compiled plans.
+
+    Extends ``generate_branch_seeds`` to reach the synthesis and composer
+    producers — both of which emit ``(seed, compiled_plan)`` pairs that
+    cannot be expressed through the seed-only return type of the base
+    function. Returns a tuple:
+
+      (seeds, compiled_plans_by_seed_id)
+
+    where ``compiled_plans_by_seed_id`` maps seed_id → plan dict. Seeds
+    from producers that don't compile ship with their seed_id absent
+    from the dict (e.g. analytical seeds, corpus hints).
+
+    Additional inputs beyond the base function:
+
+      synth_profiles: list of :class:`SynthProfile` objects (from
+        ``synthesis_brain.analyze_synth_patch``). When non-empty, each
+        profile is passed to ``propose_synth_branches`` and the returned
+        pairs are merged into the output. Typically the caller fetches
+        device parameters via ``ableton.send_command('get_device_parameters')``
+        and builds a profile per device before calling this function.
+
+      composer_request: natural-language composition prompt. When set,
+        ``propose_composer_branches`` is invoked with it and the emitted
+        pairs are merged. For composition-shaped requests, pass
+        ``request_text`` here.
+
+      composer_count: max composer branches to emit (default 2).
+
+    Ordering matches generate_branch_seeds where sources overlap:
+    semantic_move → technique → synthesis → sacred-inversion → composer
+    → corpus hints. max_seeds still caps total output.
+    """
+    # Base seeds (semantic_move, technique, sacred-inversion, corpus)
+    base_seeds = generate_branch_seeds(
+        request_text=request_text,
+        kernel=kernel,
+        song_brain=song_brain,
+        active_constraints=active_constraints,
+        taste_graph=taste_graph,
+        max_seeds=max_seeds,
+    )
+
+    # Copy the base seeds so we can interleave producer seeds without
+    # mutating the cached list (if the caller happens to share it).
+    seeds: list[BranchSeed] = list(base_seeds)
+    plans_by_seed: dict[str, dict] = {}
+    used_hypotheses = {s.hypothesis.lower() for s in seeds}
+    budget_remaining = max(0, max_seeds - len(seeds))
+
+    # ── synthesis producer ────────────────────────────────────────────
+    if budget_remaining > 0 and synth_profiles:
+        try:
+            from ..synthesis_brain import propose_synth_branches
+        except ImportError as exc:
+            logger.warning("synthesis_brain unavailable: %s", exc)
+            propose_synth_branches = None
+
+        if propose_synth_branches is not None:
+            for profile in synth_profiles:
+                if budget_remaining <= 0:
+                    break
+                try:
+                    pairs = propose_synth_branches(profile, kernel=kernel)
+                except Exception as exc:
+                    logger.warning(
+                        "propose_synth_branches failed for %s: %s",
+                        getattr(profile, "device_name", "?"),
+                        exc,
+                    )
+                    continue
+                for seed, plan in pairs:
+                    if budget_remaining <= 0:
+                        break
+                    if seed.hypothesis.lower() in used_hypotheses:
+                        continue
+                    seeds.append(seed)
+                    plans_by_seed[seed.seed_id] = plan
+                    used_hypotheses.add(seed.hypothesis.lower())
+                    budget_remaining -= 1
+
+    # ── composer producer ────────────────────────────────────────────
+    if budget_remaining > 0 and composer_request:
+        try:
+            from ..composer import propose_composer_branches
+        except ImportError as exc:
+            logger.warning("composer branch producer unavailable: %s", exc)
+            propose_composer_branches = None
+
+        if propose_composer_branches is not None:
+            try:
+                comp_pairs = propose_composer_branches(
+                    request_text=composer_request,
+                    kernel=kernel,
+                    count=min(composer_count, budget_remaining),
+                )
+            except Exception as exc:
+                logger.warning("propose_composer_branches failed: %s", exc)
+                comp_pairs = []
+
+            for seed, plan in comp_pairs:
+                if budget_remaining <= 0:
+                    break
+                if seed.hypothesis.lower() in used_hypotheses:
+                    continue
+                seeds.append(seed)
+                if plan:  # composer may return {} for analytical-only branches
+                    plans_by_seed[seed.seed_id] = plan
+                used_hypotheses.add(seed.hypothesis.lower())
+                budget_remaining -= 1
+
+    return seeds, plans_by_seed

package/mcp_server/wonder_mode/tools.py

@@ -17,6 +17,96 @@ from . import engine
 logger = logging.getLogger(__name__)
 
 
+def _build_synth_profiles_for_wonder(ctx, request_text: str, diagnosis: dict) -> list:
+    """Build SynthProfile objects for every track holding a native synth.
+
+    Wires the synthesis_brain producer into enter_wonder_mode's runtime
+    flow — without this helper, ``propose_synth_branches`` is registered
+    but unreachable from the MCP surface.
+
+    Returns a list of SynthProfile objects (possibly empty). All errors
+    are swallowed and logged — missing devices, disconnected Ableton,
+    unsupported devices all land as "no synth branches" rather than
+    failing the whole wonder session.
+    """
+    try:
+        from ..synthesis_brain import analyze_synth_patch, supported_devices
+    except ImportError as exc:
+        logger.debug("synthesis_brain not importable: %s", exc)
+        return []
+
+    ableton = ctx.lifespan_context.get("ableton")
+    if ableton is None:
+        return []
+
+    try:
+        session = ableton.send_command("get_session_info", {})
+    except Exception as exc:
+        logger.debug("session fetch for synth profiles failed: %s", exc)
+        return []
+    if not isinstance(session, dict) or "error" in session:
+        return []
+
+    native_names = set(supported_devices())
+    profiles: list = []
+
+    tracks = session.get("tracks") or []
+    for track in tracks:
+        track_index = track.get("index")
+        devices = track.get("devices") or []
+        if track_index is None or not devices:
+            continue
+        for dev in devices:
+            dev_name = dev.get("name") or dev.get("class_name") or ""
+            if dev_name not in native_names:
+                continue
+            dev_index = dev.get("index")
+            if dev_index is None:
+                continue
+            try:
+                params_result = ableton.send_command(
+                    "get_device_parameters",
+                    {"track_index": track_index, "device_index": dev_index},
+                )
+            except Exception as exc:
+                logger.debug(
+                    "get_device_parameters failed for track=%s device=%s: %s",
+                    track_index, dev_index, exc,
+                )
+                continue
+            if not isinstance(params_result, dict) or "error" in params_result:
+                continue
+
+            parameter_state = {}
+            display_values = {}
+            for p in params_result.get("parameters", []) or []:
+                name = p.get("name")
+                if name is None:
+                    continue
+                parameter_state[name] = p.get("value")
+                if "value_string" in p:
+                    display_values[name] = p["value_string"]
+
+            try:
+                profile = analyze_synth_patch(
+                    device_name=dev_name,
+                    track_index=track_index,
+                    device_index=dev_index,
+                    parameter_state=parameter_state,
+                    display_values=display_values,
+                    role_hint=track.get("name", ""),
+                )
+                profiles.append(profile)
+            except Exception as exc:
+                logger.warning(
+                    "analyze_synth_patch failed for %s on track %s: %s",
+                    dev_name, track_index, exc,
+                )
+                continue
+
+    return profiles
+
+
 def _get_song_brain_dict() -> dict:
     try:
         from ..song_brain.tools import _current_brain
@@ -164,7 +254,7 @@ def enter_wonder_mode(
     except Exception as exc:
         logger.warning("session_info fetch for kernel failed: %s", exc)
 
-    # 2. Generate variants
+    # 2. Generate variants (legacy path)
     result = engine.generate_wonder_variants(
         request_text=request_text,
         diagnosis=diag_dict,
@@ -176,6 +266,58 @@ def enter_wonder_mode(
         sample_context=sample_context,
     )
 
+    # 2b. PR6 — also emit BranchSeeds for the branch-native experiment flow.
+    # Pull session_memory from the conversation lifespan when available so
+    # technique seeds can be sourced. Kernel state here is a lightweight
+    # dict — enter_wonder_mode doesn't always have a full SessionKernel.
+    branch_kernel: dict = {}
+    try:
+        from ..memory.session_memory import SessionMemoryStore
+        mem_store = ctx.lifespan_context.setdefault("session_memory", SessionMemoryStore())
+        branch_kernel["session_memory"] = [
+            entry.to_dict() for entry in mem_store.get_recent(limit=10)
+        ]
+    except Exception as exc:
+        logger.debug("session_memory fetch for seeds failed: %s", exc)
+    # Freshness defaults to 0.5 — enter_wonder_mode is inherently exploratory,
+    # so lean slightly toward surprise.
+    branch_kernel["freshness"] = 0.65
+
+    # Build SynthProfiles for tracks mentioned in the request or for every
+    # track that holds a native synth. Lets propose_synth_branches reach
+    # the runtime — without this the producer is dark despite being
+    # registered in the conductor.
+    synth_profiles = _build_synth_profiles_for_wonder(ctx, request_text, diag_dict)
+
+    # Composer branches fire when the base conductor routes to
+    # composition — otherwise we'd be emitting composition scaffolding
+    # for every mix/transition request, which is noise.
+    composer_request: str = ""
+    try:
+        from ..tools._conductor import classify_request
+        base_plan = classify_request(request_text)
+        if base_plan.routes and base_plan.routes[0].engine == "composition":
+            composer_request = request_text
+    except Exception as exc:
+        logger.debug("composer routing check failed: %s", exc)
+
+    try:
+        branch_seeds, compiled_plans_by_seed = engine.generate_branch_seeds_and_plans(
+            request_text=request_text,
+            kernel=branch_kernel,
+            song_brain=song_brain,
+            active_constraints=active_constraints,
+            taste_graph=taste_graph,
+            synth_profiles=synth_profiles,
+            composer_request=composer_request or None,
+        )
+        branch_seeds_dicts = [s.to_dict() for s in branch_seeds]
+    except Exception as exc:
+        # Seed assembly is additive — never let it break wonder mode.
+        logger.warning("generate_branch_seeds_and_plans failed: %s", exc)
+        branch_seeds_dicts = []
+        compiled_plans_by_seed = {}
+
     # 3. Create WonderSession (unique per invocation, not deterministic)
     import hashlib, time
     _seed = f"{request_text}:{kernel_id}:{time.time()}"
@@ -217,6 +359,16 @@ def enter_wonder_mode(
         "recommended": result.get("recommended", ""),
         "variant_count_actual": result.get("variant_count_actual", 0),
         "degraded_reason": ws.degraded_reason,
+        # Branch-native seeds from six producers (semantic_move, technique,
+        # synthesis, sacred-inversion, composer, corpus). Feed directly to
+        # create_experiment(seeds=[...], compiled_plans=[...]) — align the
+        # compiled_plans list with branch_seeds by matching seed_ids.
+        "branch_seeds": branch_seeds_dicts,
+        # seed_id → pre-compiled plan dict. Only synthesis and composer
+        # seeds currently populate this — other sources either defer
+        # compilation to run_experiment (semantic_move) or stay analytical
+        # (technique reuse, sacred-inversion, corpus hints).
+        "compiled_plans_by_seed_id": compiled_plans_by_seed,
         "mode": "wonder",
     }
 

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.12.2",
+  "version": "1.14.0",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 398 tools, 51 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 — 402 tools, 52 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",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.12.2"
+__version__ = "1.14.0"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/server.json

@@ -1,17 +1,17 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.dreamrec/livepilot",
-  "description": "398-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
+  "description": "402-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
   "repository": {
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.12.2",
+  "version": "1.14.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.12.2",
+      "version": "1.14.0",
       "transport": {
         "type": "stdio"
       }