livepilot 1.12.2 → 1.14.0

package/mcp_server/memory/taste_graph.py

@@ -75,13 +75,37 @@ class TasteGraph:
     # Device preferences
     device_affinities: dict[str, DeviceAffinity] = field(default_factory=dict)
 
-    # Novelty tolerance: 0 = very conservative, 1 = very experimental
-    novelty_band: float = 0.5
+    # PR8 — per-goal-mode novelty bands. Canonical source of truth.
+    # Keys are goal modes ("improve", "explore", or any string a caller
+    # supplies). novelty_band (below, as a property) reads/writes
+    # novelty_bands["improve"] — one storage, two access paths.
+    novelty_bands: dict = field(
+        default_factory=lambda: {"improve": 0.5, "explore": 0.5}
+    )
+
+    # PR8 — when True, rank_moves returns uniform taste scores (0.5) to
+    # bypass taste filtering during branch generation. Callers flip this
+    # for fresh / surprise-me mode so novelty survives to post-hoc ranking.
+    bypass_taste_in_generation: bool = False
 
     # Total evidence count (how many decisions informed this graph)
     evidence_count: int = 0
     last_updated_ms: int = 0
 
+    @property
+    def novelty_band(self) -> float:
+        """Legacy flat novelty band — mirrors novelty_bands["improve"].
+
+        Kept for back-compat with callers that set/read novelty_band
+        directly. Setting this property writes through to the bands dict
+        so there's no dual source of truth.
+        """
+        return self.novelty_bands.get("improve", 0.5)
+
+    @novelty_band.setter
+    def novelty_band(self, value: float) -> None:
+        self.novelty_bands["improve"] = float(value)
+
     def to_dict(self) -> dict:
         return {
             "dimension_weights": self.dimension_weights,
@@ -96,7 +120,11 @@ class TasteGraph:
                     key=lambda x: -x[1].affinity,
                 )[:10]  # Top 10 only
             },
+            # novelty_band kept for legacy consumers that read it directly;
+            # novelty_bands is the canonical per-goal-mode shape going forward.
             "novelty_band": round(self.novelty_band, 3),
+            "novelty_bands": {k: round(v, 3) for k, v in self.novelty_bands.items()},
+            "bypass_taste_in_generation": self.bypass_taste_in_generation,
             "evidence_count": self.evidence_count,
         }
 
@@ -154,21 +182,53 @@ class TasteGraph:
         self.evidence_count += 1
         self.last_updated_ms = now
 
-    def update_novelty_from_experiment(self, chose_bold: bool) -> None:
-        """Shift novelty band based on experiment choices."""
+    def update_novelty_from_experiment(
+        self, chose_bold: bool, goal_mode: str = "improve",
+    ) -> None:
+        """Shift novelty band for a given goal mode based on experiment choices.
+
+        PR8: goal_mode defaults to "improve" so legacy callers land on the
+        same band they updated before. Pass "explore" to shift the
+        exploration-mode band without touching improve-mode preference.
+        (novelty_band is a property view over novelty_bands["improve"], so
+        improve-mode updates automatically surface there too.)
+        """
+        current = self.novelty_bands.get(goal_mode, 0.5)
         if chose_bold:
-            self.novelty_band = min(1.0, self.novelty_band + 0.05)
+            new_val = min(1.0, current + 0.05)
         else:
-            self.novelty_band = max(0.0, self.novelty_band - 0.05)
+            new_val = max(0.0, current - 0.05)
+        self.novelty_bands[goal_mode] = new_val
 
     # ── Ranking ──────────────────────────────────────────────────────
 
-    def rank_moves(self, move_specs: list[dict]) -> list[dict]:
+    def rank_moves(
+        self,
+        move_specs: list[dict],
+        goal_mode: str = "improve",
+    ) -> list[dict]:
         """Rank a list of semantic move dicts by taste fit.
 
         Each move dict should have: move_id, family, targets, risk_level.
         Returns the same dicts with added 'taste_score' field, sorted desc.
+
+        PR8 additions:
+          goal_mode (str, default "improve"): which novelty band to use for
+            risk alignment. "improve" respects the user's conservative history;
+            "explore" uses the explore-mode band so past timid choices don't
+            punish surprise-me branch generation.
+          bypass_taste_in_generation (instance flag): when True, every move
+            scores a uniform 0.5. Used during branch generation so taste
+            doesn't prune novelty before the user has a chance to audition.
+            Ranking order is preserved from input when this flag is on.
         """
+        if self.bypass_taste_in_generation:
+            return [dict(move, taste_score=0.5) for move in move_specs]
+
+        # Read the band for the requested mode. Falls back to the improve
+        # band (via self.novelty_band property) when the mode is unknown.
+        novelty_band = self.novelty_bands.get(goal_mode, self.novelty_band)
+
         ranked = []
         for move in move_specs:
             taste_score = 0.5  # Neutral baseline
@@ -190,10 +250,10 @@ class TasteGraph:
                 if dim in self.dimension_avoidances:
                     taste_score -= 0.3
 
-            # Novelty/risk alignment
+            # Novelty/risk alignment (PR8: per-mode band)
             risk = move.get("risk_level", "low")
             risk_val = {"low": 0.2, "medium": 0.5, "high": 0.8}.get(risk, 0.5)
-            novelty_match = 1.0 - abs(risk_val - self.novelty_band)
+            novelty_match = 1.0 - abs(risk_val - novelty_band)
             taste_score += novelty_match * 0.1
 
             # Clamp
@@ -297,8 +357,21 @@ def build_taste_graph(
                 if total > 0:
                     fam.score = round((fam.kept_count - fam.undone_count) / total, 3)
 
-        # Novelty band
-        graph.novelty_band = persisted.get("novelty_band", 0.5)
+        # Novelty band — migrate from flat float if present, OR read
+        # per-mode dict if newer persistence format has it (PR8).
+        persisted_band = persisted.get("novelty_band", 0.5)
+        persisted_bands = persisted.get("novelty_bands")
+        if isinstance(persisted_bands, dict) and persisted_bands:
+            graph.novelty_bands = {
+                k: float(v) for k, v in persisted_bands.items() if isinstance(v, (int, float))
+            }
+            # Ensure both canonical keys are present with sensible defaults.
+            graph.novelty_bands.setdefault("improve", persisted_band)
+            graph.novelty_bands.setdefault("explore", persisted_band)
+            graph.novelty_band = graph.novelty_bands["improve"]
+        else:
+            graph.novelty_band = persisted_band
+            graph.novelty_bands = {"improve": persisted_band, "explore": persisted_band}
 
         # Device affinities
         for dev_name, dev_data in persisted.get("device_affinities", {}).items():

package/mcp_server/persistence/taste_store.py

@@ -48,15 +48,29 @@ class PersistentTasteStore:
             return data
         self._store.update(_update)
 
-    def update_novelty(self, chose_bold: bool) -> None:
-        """Update novelty band from experiment choice."""
+    def update_novelty(self, chose_bold: bool, goal_mode: str = "improve") -> None:
+        """Update novelty band from experiment choice for a given goal mode.
+
+        PR8: goal_mode defaults to "improve" so legacy callers land on the
+        same band they updated before. The per-mode dict ``novelty_bands``
+        is maintained alongside the flat ``novelty_band`` field; the flat
+        field mirrors the "improve" band.
+        """
         def _update(data: dict) -> dict:
             data = data if data.get("version") == 1 else self._default()
-            band = data.get("novelty_band", 0.5)
+            # Ensure the per-mode dict exists (migrating from legacy shape).
+            bands = data.get("novelty_bands")
+            if not isinstance(bands, dict) or not bands:
+                flat = data.get("novelty_band", 0.5)
+                bands = {"improve": flat, "explore": flat}
+            current = bands.get(goal_mode, 0.5)
             if chose_bold:
-                data["novelty_band"] = min(1.0, band + 0.05)
+                bands[goal_mode] = min(1.0, current + 0.05)
             else:
-                data["novelty_band"] = max(0.0, band - 0.05)
+                bands[goal_mode] = max(0.0, current - 0.05)
+            data["novelty_bands"] = bands
+            # Mirror the improve band onto the flat field for back-compat.
+            data["novelty_band"] = bands.get("improve", 0.5)
             data["evidence_count"] = data.get("evidence_count", 0) + 1
             return data
         self._store.update(_update)
@@ -114,6 +128,8 @@ class PersistentTasteStore:
             "version": 1,
             "move_outcomes": {},
             "novelty_band": 0.5,
+            # PR8 — per-goal-mode novelty bands; novelty_band mirrors "improve"
+            "novelty_bands": {"improve": 0.5, "explore": 0.5},
             "device_affinities": {},
             "anti_preferences": [],
             "dimension_weights": {},

package/mcp_server/runtime/session_kernel.py

@@ -45,6 +45,37 @@ class SessionKernel:
     recommended_engines: list = field(default_factory=list)
     recommended_workflow: str = ""
 
+    # ── Creative controls (PR2 — branch-native migration) ──────────────
+    # All optional. Producers (Wonder, synthesis_brain, composer) read these
+    # to bias branch generation. Pre-PR2 callers leave them at defaults and
+    # nothing changes. PR6 (Wonder refactor) and PR9 (synthesis_brain) start
+    # reading them in earnest.
+
+    # 0.0 = conservative / don't surprise me; 1.0 = surprise me.
+    # Distinct from aggression (which is about execution boldness).
+    freshness: float = 0.5
+
+    # Shorthand producer philosophy tag. The sample_engine already uses
+    # "surgeon" / "alchemist" (see livepilot-sample-engine); synth work
+    # may add "sculptor". Empty string = producer picks a default.
+    creativity_profile: str = ""
+
+    # Caller-asserted sacred elements. Normally sacred elements come from
+    # song_brain; this lets the user or a skill override. Shape matches
+    # song_brain.sacred_elements entries: {element_type, description, salience}.
+    sacred_elements: list = field(default_factory=list)
+
+    # Hints for synthesis_brain: which tracks/devices to focus on and what
+    # target timbre to aim for. Shape is open in PR2 and will be firmed up
+    # when PR9 adds the first adapters.
+    #   {
+    #     "track_indices": [int, ...],
+    #     "device_paths":  ["track/Wavetable", ...],
+    #     "target_timbre": {"brightness": +0.3, "width": +0.2, ...},
+    #     "preferred_devices": ["Wavetable", "Operator", ...],
+    #   }
+    synth_hints: dict = field(default_factory=dict)
+
     def to_dict(self) -> dict:
         return asdict(self)
 
@@ -60,12 +91,23 @@ def build_session_kernel(
     taste_graph: Optional[dict] = None,
     anti_preferences: Optional[list] = None,
     protected_dimensions: Optional[dict] = None,
+    # PR2 — creative controls. All optional; legacy callers unaffected.
+    freshness: float = 0.5,
+    creativity_profile: str = "",
+    sacred_elements: Optional[list] = None,
+    synth_hints: Optional[dict] = None,
 ) -> SessionKernel:
     """Build a SessionKernel from raw data.
 
     All optional fields degrade gracefully to empty defaults.
     The kernel_id is deterministic from the core inputs so it's stable
     within the same turn context.
+
+    The PR2 creative-control fields (freshness, creativity_profile,
+    sacred_elements, synth_hints) are intentionally excluded from the
+    kernel_id hash so existing callers see no identity changes. Producers
+    that need these fields to influence identity can compose their own
+    derived id downstream.
     """
     # Deterministic kernel_id from inputs
     id_seed = json.dumps(
@@ -93,4 +135,8 @@ def build_session_kernel(
         taste_graph=taste_graph or {},
         anti_preferences=anti_preferences or [],
         protected_dimensions=protected_dimensions or {},
+        freshness=freshness,
+        creativity_profile=creativity_profile,
+        sacred_elements=sacred_elements or [],
+        synth_hints=synth_hints or {},
     )

package/mcp_server/runtime/tools.py

@@ -7,6 +7,8 @@ Tools:
 
 from __future__ import annotations
 
+from typing import Optional
+
 from fastmcp import Context
 
 from ..server import mcp
@@ -79,6 +81,10 @@ def get_session_kernel(
     request_text: str = "",
     mode: str = "improve",
     aggression: float = 0.5,
+    freshness: float = 0.5,
+    creativity_profile: str = "",
+    sacred_elements: Optional[list] = None,
+    synth_hints: Optional[dict] = None,
 ) -> dict:
     """Build the unified turn snapshot for V2 orchestration.
 
@@ -86,11 +92,27 @@ def get_session_kernel(
     Assembles: session info, capability state, action ledger, taste profile,
     anti-preferences, and session memory into one canonical snapshot.
 
-    mode: observe | improve | explore | finish | diagnose
-    aggression: 0.0 (subtle) to 1.0 (bold)
+    Core params:
+      mode: observe | improve | explore | finish | diagnose
+      aggression: 0.0 (subtle) to 1.0 (bold) — execution boldness.
+
+    Creative controls (PR2 — branch-native migration, optional):
+      freshness: 0.0 (don't surprise me) to 1.0 (surprise me). Read by
+        producers (Wonder, synthesis_brain, composer) to bias branch
+        generation. Distinct from aggression, which is about applying
+        a single move boldly; freshness is about how far to roam.
+      creativity_profile: shorthand producer philosophy tag. Known values
+        include "surgeon" (targeted), "alchemist" (transformative),
+        "sculptor" (synthesis-focused). Empty ⇒ producer picks a default.
+      sacred_elements: caller-asserted list of sacred elements that
+        override or augment what song_brain infers. Shape matches
+        song_brain entries: {element_type, description, salience}.
+      synth_hints: focus hints for synthesis_brain; shape is open in PR2
+        and firms up in PR9. Typical keys: track_indices, device_paths,
+        target_timbre, preferred_devices.
 
     Returns: SessionKernel dict with kernel_id, session topology, capabilities,
-    memory context, and routing hints.
+    memory context, routing hints, and (if provided) creative controls.
     """
     from .session_kernel import build_session_kernel
 
@@ -179,6 +201,10 @@ def get_session_kernel(
         session_memory=session_mem,
         taste_graph=taste_graph,
         anti_preferences=anti_prefs,
+        freshness=freshness,
+        creativity_profile=creativity_profile,
+        sacred_elements=sacred_elements,
+        synth_hints=synth_hints,
     )
 
     # Populate routing hints from conductor when request context is available

package/mcp_server/server.py

@@ -305,6 +305,7 @@ from .device_forge import tools as device_forge_tools          # noqa: F401, E40
 from .sample_engine import tools as sample_engine_tools        # noqa: F401, E402
 from .atlas import tools as atlas_tools                        # noqa: F401, E402
 from .composer import tools as composer_tools                  # noqa: F401, E402
+from .synthesis_brain import tools as synthesis_brain_tools    # noqa: F401, E402
 from .tools import diagnostics   # noqa: F401, E402
 from .tools import miditool       # noqa: F401, E402
 

package/mcp_server/synthesis_brain/__init__.py

@@ -0,0 +1,53 @@
+"""Synthesis brain — native-synth-aware branch production.
+
+Parallel subsystem to mcp_server.sound_design. Where sound_design reasons
+at the block-type level (oscillator / filter / envelope / ...), the
+synthesis brain reasons at the native-device level with per-adapter
+knowledge of Wavetable / Operator / Analog / Drift / Meld parameter
+spaces, modulation graphs, and articulation profiles.
+
+Each adapter implements the SynthAdapter protocol:
+  - device_name: the Ableton device name it claims
+  - extract_profile(device_parameters): read a SynthProfile from live params
+  - propose_branches(profile, target, kernel): emit BranchSeed objects plus
+    pre-compiled plans (set_device_parameter / batch_set_parameters steps)
+
+PR9 ships Wavetable and Operator adapters. PR10 adds Analog, Drift, Meld
+and render-based timbre extraction on top of ``capture_audio``.
+
+No MCP @tool() decorators in this PR — the subsystem is callable from
+Python (Wonder's generate_branch_seeds, composer, etc.). PR12 wires
+dedicated MCP tools and does the tool-count metadata sweep in one pass.
+"""
+
+from .models import (
+    SynthProfile,
+    TimbralFingerprint,
+    ModulationGraph,
+    ArticulationProfile,
+    OPAQUE,
+    NATIVE,
+)
+from .adapters import get_adapter, SynthAdapter
+from .engine import (
+    analyze_synth_patch,
+    propose_synth_branches,
+    supported_devices,
+)
+from .timbre import extract_timbre_fingerprint, diff_fingerprint
+
+__all__ = [
+    "SynthProfile",
+    "TimbralFingerprint",
+    "ModulationGraph",
+    "ArticulationProfile",
+    "OPAQUE",
+    "NATIVE",
+    "SynthAdapter",
+    "get_adapter",
+    "analyze_synth_patch",
+    "propose_synth_branches",
+    "supported_devices",
+    "extract_timbre_fingerprint",
+    "diff_fingerprint",
+]

package/mcp_server/synthesis_brain/adapters/__init__.py

@@ -0,0 +1,34 @@
+"""Synth adapter registry.
+
+Each adapter is a Python class implementing the SynthAdapter protocol.
+Registration is explicit — adapters add themselves to ``_REGISTRY`` at
+module import time. ``get_adapter(device_name)`` returns the registered
+adapter or None.
+"""
+
+from __future__ import annotations
+
+from .base import SynthAdapter, _REGISTRY, register_adapter
+from . import wavetable as _wavetable  # noqa: F401 — import for registration
+from . import operator as _operator  # noqa: F401
+from . import analog as _analog  # noqa: F401
+from . import drift as _drift  # noqa: F401
+from . import meld as _meld  # noqa: F401
+
+
+def get_adapter(device_name: str) -> SynthAdapter | None:
+    """Return the adapter for a given Ableton device name, or None."""
+    return _REGISTRY.get(device_name)
+
+
+def registered_devices() -> list[str]:
+    """List device names this package has an adapter for."""
+    return sorted(_REGISTRY.keys())
+
+
+__all__ = [
+    "SynthAdapter",
+    "get_adapter",
+    "register_adapter",
+    "registered_devices",
+]