livepilot 1.13.0 → 1.14.0

package/mcp_server/synthesis_brain/adapters/analog.py

@@ -104,62 +104,168 @@ class AnalogAdapter:
         target: TimbralFingerprint,
         kernel: Optional[dict] = None,
     ) -> list[tuple[BranchSeed, dict]]:
+        # Strategy registry — each candidate strategy's ``applicable()``
+        # gates on profile+role+target, and ``build()`` emits (seed, plan).
+        # Adapter returns ALL applicable strategies' proposals so Wonder /
+        # create_experiment can offer them as branches. Callers cap total
+        # via max_seeds.
         kernel = kernel or {}
-        freshness = float(kernel.get("freshness", 0.5) or 0.5)
-        track = profile.track_index
-        device = profile.device_index
-
-        # Skip proposal if already plucky — avoids doubling-down on the
-        # same treatment.
-        if any("Already plucky" in n for n in profile.notes):
-            return []
-
-        current_env = float(profile.parameter_state.get("F1 Env Amount", 0.0) or 0.0)
-        # Target filter-env amount scales with freshness.
-        new_env = min(1.0, max(current_env, 0.45 if freshness < 0.5 else 0.65))
-        current_decay = float(profile.parameter_state.get("F1 Env D", 0.5) or 0.5)
-        new_decay = min(current_decay, 0.25 if freshness < 0.5 else 0.15)
-
-        seed = freeform_seed(
-            seed_id=_short_id("an_plk", f"{track}:{device}:{new_env:.2f}:{new_decay:.2f}"),
-            hypothesis=(
-                f"Analog filter-pluck: Env Amount → {new_env:.2f}, "
-                f"Decay → {new_decay:.2f} for attack character"
-            ),
-            source="synthesis",
-            novelty_label="strong" if freshness < 0.7 else "unexpected",
-            risk_label="low",
-            affected_scope={
-                "track_indices": [track],
-                "device_paths": [f"track/{track}/device/{device}"],
+        results: list[tuple[BranchSeed, dict]] = []
+        for strategy_fn in (_strategy_filter_pluck, _strategy_detune_warmth):
+            try:
+                maybe = strategy_fn(profile, target, kernel, adapter=self)
+            except Exception:
+                # Never let one strategy's crash kill the rest.
+                continue
+            if maybe is not None:
+                results.append(maybe)
+        return results
+
+
+# ── Strategy registry ────────────────────────────────────────────────
+#
+# Each strategy is a pure function (profile, target, kernel, adapter) →
+# Optional[(BranchSeed, plan_dict)]. A strategy returns None when not
+# applicable to the current profile+target+role combination. This lets
+# the adapter stay thin while the intelligence lives in the strategies.
+
+
+def _strategy_filter_pluck(
+    profile: SynthProfile,
+    target: TimbralFingerprint,
+    kernel: dict,
+    adapter,
+) -> Optional[tuple[BranchSeed, dict]]:
+    """Couple Filter Env Amount up + Filter Decay down → attack pluck.
+
+    Gates: skip when profile already flags 'Already plucky'. Most useful
+    when role_hint is "bass", "pluck", "lead", or when target.bite > 0.
+    """
+    if any("Already plucky" in n for n in profile.notes):
+        return None
+
+    role = (profile.role_hint or "").lower()
+    want_bite = target.bite > 0.1 or role in {"bass", "pluck", "lead", "stab"}
+    if not want_bite and role in {"pad", "drone"}:
+        # Sustained roles actively fight this strategy.
+        return None
+
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+    track = profile.track_index
+    device = profile.device_index
+    current_env = float(profile.parameter_state.get("F1 Env Amount", 0.0) or 0.0)
+    new_env = min(1.0, max(current_env, 0.45 if freshness < 0.5 else 0.65))
+    current_decay = float(profile.parameter_state.get("F1 Env D", 0.5) or 0.5)
+    new_decay = min(current_decay, 0.25 if freshness < 0.5 else 0.15)
+
+    seed = freeform_seed(
+        seed_id=_short_id("an_plk", f"{track}:{device}:{new_env:.2f}:{new_decay:.2f}"),
+        hypothesis=(
+            f"Analog filter-pluck: Env Amount → {new_env:.2f}, "
+            f"Decay → {new_decay:.2f} for attack character"
+        ),
+        source="synthesis",
+        novelty_label="strong" if freshness < 0.7 else "unexpected",
+        risk_label="low",
+        affected_scope={
+            "track_indices": [track],
+            "device_paths": [f"track/{track}/device/{device}"],
+        },
+        distinctness_reason="couples Filter Env Amount + Decay for attack character",
+        producer_payload={
+            "device_name": adapter.device_name,
+            "track_index": track,
+            "device_index": device,
+            "strategy": "filter_pluck",
+            "topology_hint": {
+                "role_hint": profile.role_hint,
+                "current_env": current_env,
+                "new_env": new_env,
+                "current_decay": current_decay,
+                "new_decay": new_decay,
             },
-            distinctness_reason="only Analog seed that couples Filter Env + Decay",
-        )
-        plan = {
-            "steps": [
-                {
-                    "tool": "set_device_parameter",
-                    "params": {
-                        "track_index": track,
-                        "device_index": device,
+        },
+    )
+    plan = {
+        "steps": [
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
                         "parameter_name": "F1 Env Amount",
-                        "value": round(new_env, 3),
-                    },
-                },
-                {
-                    "tool": "set_device_parameter",
-                    "params": {
-                        "track_index": track,
-                        "device_index": device,
+                        "value": round(new_env, 3)}},
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
                         "parameter_name": "F1 Env D",
-                        "value": round(new_decay, 3),
-                    },
-                },
-            ],
-            "step_count": 2,
-            "summary": f"F1 Env Amount → {new_env:.2f}, F1 Env D → {new_decay:.2f}",
-        }
-        return [(seed, plan)]
+                        "value": round(new_decay, 3)}},
+        ],
+        "step_count": 2,
+        "summary": f"F1 Env Amount → {new_env:.2f}, F1 Env D → {new_decay:.2f}",
+    }
+    return (seed, plan)
+
+
+def _strategy_detune_warmth(
+    profile: SynthProfile,
+    target: TimbralFingerprint,
+    kernel: dict,
+    adapter,
+) -> Optional[tuple[BranchSeed, dict]]:
+    """Detune Osc2 slightly + lean warmer tone.
+
+    Gates: applicable when role_hint is "pad" / "lead" / "stab" / "drone"
+    or target.warmth > 0. Skip on "pluck"/"bass" to avoid woofiness.
+    """
+    role = (profile.role_hint or "").lower()
+    if role in {"bass", "pluck", "kick"}:
+        return None
+    want_warm = target.warmth > 0.1 or role in {"pad", "lead", "stab", "drone"}
+    if not want_warm:
+        return None
+
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+    track = profile.track_index
+    device = profile.device_index
+    current_detune = float(profile.parameter_state.get("Osc2 Tune", 0.0) or 0.0)
+    # Detune is in semitones by convention on Analog; keep shifts musical.
+    step = 0.04 if freshness < 0.5 else 0.09
+    new_detune = round(current_detune + step, 3)
+
+    seed = freeform_seed(
+        seed_id=_short_id("an_det", f"{track}:{device}:{new_detune:.3f}"),
+        hypothesis=(
+            f"Analog detune warmth: Osc2 Tune {current_detune:.3f} → "
+            f"{new_detune:.3f} semitones for a wider, lusher body"
+        ),
+        source="synthesis",
+        novelty_label="safe",
+        risk_label="low",
+        affected_scope={
+            "track_indices": [track],
+            "device_paths": [f"track/{track}/device/{device}"],
+        },
+        distinctness_reason="slight Osc2 detune for body, no filter changes",
+        producer_payload={
+            "device_name": adapter.device_name,
+            "track_index": track,
+            "device_index": device,
+            "strategy": "detune_warmth",
+            "topology_hint": {
+                "role_hint": profile.role_hint,
+                "current_detune": current_detune,
+                "new_detune": new_detune,
+            },
+        },
+    )
+    plan = {
+        "steps": [
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
+                        "parameter_name": "Osc2 Tune",
+                        "value": new_detune}},
+        ],
+        "step_count": 1,
+        "summary": f"Osc2 Tune → {new_detune:.3f}",
+    }
+    return (seed, plan)
 
 
 def _short_id(prefix: str, key: str) -> str:

package/mcp_server/synthesis_brain/adapters/drift.py

@@ -105,60 +105,165 @@ class DriftAdapter:
         kernel: Optional[dict] = None,
     ) -> list[tuple[BranchSeed, dict]]:
         kernel = kernel or {}
-        freshness = float(kernel.get("freshness", 0.5) or 0.5)
-        track = profile.track_index
-        device = profile.device_index
-
-        current_char = float(profile.parameter_state.get("Character", 0.0) or 0.0)
-        current_sub = float(profile.parameter_state.get("Sub Level", 0.0) or 0.0)
-
-        # Toggle character in the opposite direction to create contrast.
-        new_char = min(1.0, max(current_char + 0.3, 0.3)) if current_char <= 0.5 else max(0.0, current_char - 0.3)
-        # Move sub slightly toward 0.3 if we're starting outside 0.2-0.4
-        target_sub = 0.3
-        new_sub = current_sub + (target_sub - current_sub) * (0.5 if freshness < 0.5 else 0.8)
-        new_sub = round(max(0.0, min(1.0, new_sub)), 3)
-
-        seed = freeform_seed(
-            seed_id=_short_id("dr_chr", f"{track}:{device}:{new_char:.2f}:{new_sub:.2f}"),
-            hypothesis=(
-                f"Drift character blend: Character → {new_char:.2f}, "
-                f"Sub Level → {new_sub:.2f} for a different core tone"
-            ),
-            source="synthesis",
-            novelty_label="strong",
-            risk_label="low",
-            affected_scope={
-                "track_indices": [track],
-                "device_paths": [f"track/{track}/device/{device}"],
+        results: list[tuple[BranchSeed, dict]] = []
+        for strategy_fn in (_strategy_character_blend, _strategy_filter_sweep):
+            try:
+                maybe = strategy_fn(profile, target, kernel, adapter=self)
+            except Exception:
+                continue
+            if maybe is not None:
+                results.append(maybe)
+        return results
+
+
+# ── Strategy registry ────────────────────────────────────────────────
+
+
+def _strategy_character_blend(
+    profile: SynthProfile,
+    target: TimbralFingerprint,
+    kernel: dict,
+    adapter,
+) -> Optional[tuple[BranchSeed, dict]]:
+    """Shift Character + Sub balance. Always applicable."""
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+    track = profile.track_index
+    device = profile.device_index
+    current_char = float(profile.parameter_state.get("Character", 0.0) or 0.0)
+    current_sub = float(profile.parameter_state.get("Sub Level", 0.0) or 0.0)
+
+    new_char = (
+        min(1.0, max(current_char + 0.3, 0.3))
+        if current_char <= 0.5
+        else max(0.0, current_char - 0.3)
+    )
+    target_sub = 0.3
+    new_sub = current_sub + (target_sub - current_sub) * (
+        0.5 if freshness < 0.5 else 0.8
+    )
+    new_sub = round(max(0.0, min(1.0, new_sub)), 3)
+
+    seed = freeform_seed(
+        seed_id=_short_id("dr_chr", f"{track}:{device}:{new_char:.2f}:{new_sub:.2f}"),
+        hypothesis=(
+            f"Drift character blend: Character → {new_char:.2f}, "
+            f"Sub Level → {new_sub:.2f} for a different core tone"
+        ),
+        source="synthesis",
+        novelty_label="strong",
+        risk_label="low",
+        affected_scope={
+            "track_indices": [track],
+            "device_paths": [f"track/{track}/device/{device}"],
+        },
+        distinctness_reason="shifts Character + Sub balance",
+        producer_payload={
+            "device_name": adapter.device_name,
+            "track_index": track,
+            "device_index": device,
+            "strategy": "character_blend",
+            "topology_hint": {
+                "role_hint": profile.role_hint,
+                "current_char": current_char,
+                "new_char": round(new_char, 3),
+                "current_sub": current_sub,
+                "new_sub": new_sub,
             },
-            distinctness_reason="only Drift seed that shifts Character + Sub balance",
-        )
-        plan = {
-            "steps": [
-                {
-                    "tool": "set_device_parameter",
-                    "params": {
-                        "track_index": track,
-                        "device_index": device,
+        },
+    )
+    plan = {
+        "steps": [
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
                         "parameter_name": "Character",
-                        "value": round(new_char, 3),
-                    },
-                },
-                {
-                    "tool": "set_device_parameter",
-                    "params": {
-                        "track_index": track,
-                        "device_index": device,
+                        "value": round(new_char, 3)}},
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
                         "parameter_name": "Sub Level",
-                        "value": new_sub,
-                    },
-                },
-            ],
-            "step_count": 2,
-            "summary": f"Character → {new_char:.2f}, Sub Level → {new_sub:.2f}",
-        }
-        return [(seed, plan)]
+                        "value": new_sub}},
+        ],
+        "step_count": 2,
+        "summary": f"Character → {new_char:.2f}, Sub Level → {new_sub:.2f}",
+    }
+    return (seed, plan)
+
+
+def _strategy_filter_sweep(
+    profile: SynthProfile,
+    target: TimbralFingerprint,
+    kernel: dict,
+    adapter,
+) -> Optional[tuple[BranchSeed, dict]]:
+    """Sweep Filter Freq toward target brightness.
+
+    Gates: applicable when target.brightness != 0 OR role_hint suggests
+    motion ("lead", "pad", "drone"). Skip when role is "bass" (sub roles
+    want a stable low-pass, not a sweep).
+    """
+    role = (profile.role_hint or "").lower()
+    if role in {"bass", "sub", "kick"}:
+        return None
+    want_motion = abs(target.brightness) > 0.1 or role in {"lead", "pad", "drone"}
+    if not want_motion:
+        return None
+
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+    track = profile.track_index
+    device = profile.device_index
+    # Drift's filter freq is normalized 0-1 in the API; display is Hz.
+    current_freq = float(profile.parameter_state.get("Filter Freq", 0.5) or 0.5)
+    if target.brightness > 0:
+        # Open filter toward bright.
+        new_freq = min(1.0, current_freq + (0.15 if freshness < 0.5 else 0.3))
+        direction = "open"
+    else:
+        # Close toward warm.
+        new_freq = max(0.0, current_freq - (0.12 if freshness < 0.5 else 0.25))
+        direction = "close"
+
+    if abs(new_freq - current_freq) < 0.03:
+        return None  # barely any change — skip
+
+    seed = freeform_seed(
+        seed_id=_short_id(
+            "dr_flt", f"{track}:{device}:{direction}:{new_freq:.2f}"
+        ),
+        hypothesis=(
+            f"Drift filter sweep: Filter Freq {current_freq:.2f} → "
+            f"{new_freq:.2f} ({direction}) for a {direction}d voice"
+        ),
+        source="synthesis",
+        novelty_label="strong" if freshness < 0.7 else "unexpected",
+        risk_label="low",
+        affected_scope={
+            "track_indices": [track],
+            "device_paths": [f"track/{track}/device/{device}"],
+        },
+        distinctness_reason=f"filter {direction} without touching core oscillator",
+        producer_payload={
+            "device_name": adapter.device_name,
+            "track_index": track,
+            "device_index": device,
+            "strategy": f"filter_sweep_{direction}",
+            "topology_hint": {
+                "role_hint": profile.role_hint,
+                "target_brightness": target.brightness,
+                "current_freq": current_freq,
+                "new_freq": round(new_freq, 3),
+            },
+        },
+    )
+    plan = {
+        "steps": [
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
+                        "parameter_name": "Filter Freq",
+                        "value": round(new_freq, 3)}},
+        ],
+        "step_count": 1,
+        "summary": f"Filter Freq {current_freq:.2f} → {new_freq:.2f}",
+    }
+    return (seed, plan)
 
 
 def _short_id(prefix: str, key: str) -> str:

package/mcp_server/synthesis_brain/adapters/meld.py

@@ -102,48 +102,158 @@ class MeldAdapter:
         kernel: Optional[dict] = None,
     ) -> list[tuple[BranchSeed, dict]]:
         kernel = kernel or {}
-        freshness = float(kernel.get("freshness", 0.5) or 0.5)
-        track = profile.track_index
-        device = profile.device_index
-
-        # Algorithm indices are device-internal; we propose a relative shift
-        # by +1 (modulo a safe ceiling of 10 — Meld has 12 algos but we're
-        # conservative). Freshness amplifies the shift to +3.
-        current_algo = int(profile.parameter_state.get("Engine 1 Algorithm", 0) or 0)
-        shift = 1 if freshness < 0.5 else 3
-        new_algo = (current_algo + shift) % 10
-
-        seed = freeform_seed(
-            seed_id=_short_id("ml_algo", f"{track}:{device}:{new_algo}"),
-            hypothesis=(
-                f"Meld Engine 1 algorithm swap: {current_algo} → {new_algo} "
-                f"for a materially different core timbre"
-            ),
-            source="synthesis",
-            novelty_label="unexpected" if shift == 3 else "strong",
-            risk_label="medium",
-            affected_scope={
-                "track_indices": [track],
-                "device_paths": [f"track/{track}/device/{device}"],
+        results: list[tuple[BranchSeed, dict]] = []
+        for strategy_fn in (_strategy_engine_algo_swap, _strategy_engine_mix_shift):
+            try:
+                maybe = strategy_fn(profile, target, kernel, adapter=self)
+            except Exception:
+                continue
+            if maybe is not None:
+                results.append(maybe)
+        return results
+
+
+# ── Strategy registry ────────────────────────────────────────────────
+
+
+def _strategy_engine_algo_swap(
+    profile: SynthProfile,
+    target: TimbralFingerprint,
+    kernel: dict,
+    adapter,
+) -> Optional[tuple[BranchSeed, dict]]:
+    """Shift Engine 1 Algorithm by +1 (low freshness) or +3 (high).
+
+    Always applicable — algorithm swaps are guaranteed to change tone
+    regardless of current state.
+    """
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+    track = profile.track_index
+    device = profile.device_index
+    current_algo = int(profile.parameter_state.get("Engine 1 Algorithm", 0) or 0)
+    shift = 1 if freshness < 0.5 else 3
+    new_algo = (current_algo + shift) % 10
+
+    seed = freeform_seed(
+        seed_id=_short_id("ml_algo", f"{track}:{device}:{new_algo}"),
+        hypothesis=(
+            f"Meld Engine 1 algorithm swap: {current_algo} → {new_algo} "
+            f"for a materially different core timbre"
+        ),
+        source="synthesis",
+        novelty_label="unexpected" if shift == 3 else "strong",
+        risk_label="medium",
+        affected_scope={
+            "track_indices": [track],
+            "device_paths": [f"track/{track}/device/{device}"],
+        },
+        distinctness_reason="changes Engine 1 algorithm",
+        producer_payload={
+            "device_name": adapter.device_name,
+            "track_index": track,
+            "device_index": device,
+            "strategy": "engine_algo_swap",
+            "topology_hint": {
+                "role_hint": profile.role_hint,
+                "current_algo": current_algo,
+                "new_algo": new_algo,
             },
-            distinctness_reason="only Meld seed that changes Engine 1 algorithm",
-        )
-        plan = {
-            "steps": [
-                {
-                    "tool": "set_device_parameter",
-                    "params": {
-                        "track_index": track,
-                        "device_index": device,
+        },
+    )
+    plan = {
+        "steps": [
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
                         "parameter_name": "Engine 1 Algorithm",
-                        "value": new_algo,
-                    },
-                },
-            ],
-            "step_count": 1,
-            "summary": f"Engine 1 Algorithm {current_algo} → {new_algo}",
-        }
-        return [(seed, plan)]
+                        "value": new_algo}},
+        ],
+        "step_count": 1,
+        "summary": f"Engine 1 Algorithm {current_algo} → {new_algo}",
+    }
+    return (seed, plan)
+
+
+def _strategy_engine_mix_shift(
+    profile: SynthProfile,
+    target: TimbralFingerprint,
+    kernel: dict,
+    adapter,
+) -> Optional[tuple[BranchSeed, dict]]:
+    """Rebalance Engine 1 / Engine 2 Level for layered character.
+
+    Gates: applicable when BOTH engines have non-zero Level (mix makes
+    no sense if one engine is silent). Shifts the balance by 0.15-0.3
+    depending on freshness.
+    """
+    e1 = float(profile.parameter_state.get("Engine 1 Level", 0.0) or 0.0)
+    e2 = float(profile.parameter_state.get("Engine 2 Level", 0.0) or 0.0)
+    if e1 < 0.05 or e2 < 0.05:
+        return None  # one engine silent — mix shift is meaningless
+
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+    track = profile.track_index
+    device = profile.device_index
+
+    # Push toward the engine with LESS level currently — highlights the
+    # underused engine's character. When roughly equal, pick Engine 2.
+    if e1 < e2:
+        direction = "to_e1"
+        delta = 0.15 if freshness < 0.5 else 0.3
+        new_e1 = min(1.0, e1 + delta)
+        new_e2 = max(0.0, e2 - delta / 2)
+    else:
+        direction = "to_e2"
+        delta = 0.15 if freshness < 0.5 else 0.3
+        new_e2 = min(1.0, e2 + delta)
+        new_e1 = max(0.0, e1 - delta / 2)
+
+    seed = freeform_seed(
+        seed_id=_short_id(
+            "ml_mix", f"{track}:{device}:{direction}:{new_e1:.2f}:{new_e2:.2f}"
+        ),
+        hypothesis=(
+            f"Meld engine mix shift {direction}: E1 {e1:.2f} → {new_e1:.2f}, "
+            f"E2 {e2:.2f} → {new_e2:.2f}"
+        ),
+        source="synthesis",
+        novelty_label="strong",
+        risk_label="low",
+        affected_scope={
+            "track_indices": [track],
+            "device_paths": [f"track/{track}/device/{device}"],
+        },
+        distinctness_reason=(
+            f"Meld mix rebalance {direction}; algorithm unchanged"
+        ),
+        producer_payload={
+            "device_name": adapter.device_name,
+            "track_index": track,
+            "device_index": device,
+            "strategy": f"engine_mix_shift_{direction}",
+            "topology_hint": {
+                "role_hint": profile.role_hint,
+                "current_e1": e1,
+                "current_e2": e2,
+                "new_e1": round(new_e1, 3),
+                "new_e2": round(new_e2, 3),
+            },
+        },
+    )
+    plan = {
+        "steps": [
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
+                        "parameter_name": "Engine 1 Level",
+                        "value": round(new_e1, 3)}},
+            {"tool": "set_device_parameter",
+             "params": {"track_index": track, "device_index": device,
+                        "parameter_name": "Engine 2 Level",
+                        "value": round(new_e2, 3)}},
+        ],
+        "step_count": 2,
+        "summary": f"E1 {e1:.2f}→{new_e1:.2f}, E2 {e2:.2f}→{new_e2:.2f}",
+    }
+    return (seed, plan)
 
 
 def _short_id(prefix: str, key: str) -> str: