livepilot 1.17.1 → 1.17.2

package/mcp_server/tools/agent_os.py

@@ -240,9 +240,9 @@ def evaluate_move(
     Takes before/after sonic snapshots and the active GoalVector.
     Returns a score and keep/undo recommendation.
 
-    Snapshots should contain: spectrum (8-band dict), rms, peak.
-    Get these from get_master_spectrum + get_master_rms before and after
-    making changes.
+    Snapshots should contain: spectrum (9-band dict sub_low → air, or
+    8-band from pre-v1.16 .amxd builds), rms, peak. Get these from
+    get_master_spectrum + get_master_rms before and after making changes.
 
     Hard rules enforce undo when:
     - No measurable improvement (delta <= 0)
@@ -471,3 +471,194 @@ def route_request(
 
     plan = conductor.classify_request(request)
     return plan.to_dict()
+
+
+# ── iterate_toward_goal (closed evaluation loop) ──────────────────────
+
+
+@mcp.tool()
+async def iterate_toward_goal(
+    ctx: Context,
+    goal_vector: dict | str,
+    candidate_move_sets: list,
+    threshold: float = 0.70,
+    max_iterations: int = 3,
+    on_timeout: str = "commit_best",
+    render_verify: bool = False,
+) -> dict:
+    """Close the evaluation loop: run experiments until threshold or timeout.
+
+    Each iteration creates an experiment from one candidate_move_sets entry,
+    runs all branches (which auto-undo per-branch via the experiment engine),
+    and checks the top-ranked branch's score against the GoalVector. If score
+    >= threshold, commit that branch permanently and stop. Otherwise discard
+    the experiment and try the next candidate set. On timeout, commit the
+    best-so-far (on_timeout='commit_best') or commit nothing
+    (on_timeout='discard_on_timeout').
+
+    Args:
+        goal_vector: Compiled GoalVector dict (from compile_goal_vector) or
+            JSON string. Provides the scoring target passed through to the
+            evaluation scorer inside each run_experiment call.
+        candidate_move_sets: List of move_id lists — one per iteration.
+            Example: [["make_punchier", "widen_stereo"], ["tighten_low_end"]].
+            Iteration 0 tries the first list, iteration 1 the second, etc.
+            If shorter than max_iterations, iteration stops when exhausted.
+        threshold: Winner score required to commit early. 0.0–1.0. Default 0.70.
+        max_iterations: Hard cap on outer-loop iterations. Default 3.
+        on_timeout: "commit_best" (commit highest-scoring experiment at end)
+            or "discard_on_timeout" (no commit if threshold never met).
+        render_verify: When True each branch captures + analyzes audio
+            (~6s extra per branch). Default False.
+
+    Returns: IterationResult dict with status, iterations_run,
+        committed_experiment_id, committed_branch_id, final_score, steps,
+        reason.
+
+    Safety: Only commits when threshold_met OR (on_timeout='commit_best' AND
+    best-so-far exists). Never double-undoes — per-branch undo is handled
+    inside run_experiment; this tool only issues commit or discard.
+    """
+    import time as _time
+    from ..branches import seed_from_move_id
+    from ..experiment import engine as exp_engine
+    from ..experiment.tools import (
+        _capture_snapshot,
+        _capture_snapshot_with_render_verify,
+    )
+    from ..semantic_moves import registry, compiler
+    from ..evaluation.policy import classify_branch_outcome
+    from ._agent_os_engine import iterate_toward_goal_engine_async
+
+    gv_dict = _parse_json_param(goal_vector, "goal_vector")
+
+    if not isinstance(candidate_move_sets, list) or not all(
+        isinstance(s, list) and all(isinstance(m, str) for m in s)
+        for s in candidate_move_sets
+    ):
+        return {
+            "error": (
+                "candidate_move_sets must be a list of lists of move_id strings"
+            )
+        }
+
+    ableton = _get_ableton(ctx)
+    bridge = ctx.lifespan_context.get("m4l")
+    mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
+
+    # Pre-validate the GoalVector once — the eval_fn closure reuses this.
+    goal = engine.validate_goal_vector(
+        request_text=gv_dict.get("request_text", "iterate_toward_goal"),
+        targets=gv_dict.get("targets", {}),
+        protect=gv_dict.get("protect", {}),
+        mode=gv_dict.get("mode", "improve"),
+        aggression=float(gv_dict.get("aggression", 0.5)),
+        research_mode=gv_dict.get("research_mode", "none"),
+    )
+
+    # ── Callbacks wire the pure-logic engine to real experiment I/O ──
+
+    async def _create(move_ids: list[str]) -> str:
+        seeds = [seed_from_move_id(mid) for mid in move_ids]
+        kernel_id = f"iter_kern_{int(_time.time())}"
+        exp = exp_engine.create_experiment_from_seeds(
+            request_text=gv_dict.get("request_text", "iterate_toward_goal"),
+            seeds=seeds,
+            kernel_id=kernel_id,
+        )
+        return exp.experiment_id
+
+    async def _run(experiment_id: str):
+        experiment = exp_engine.get_experiment(experiment_id)
+        if experiment is None:
+            return None, 0.0
+
+        if render_verify:
+            capture_fn = lambda: _capture_snapshot_with_render_verify(ctx, 2.0)
+        else:
+            capture_fn = lambda: _capture_snapshot(ctx)
+
+        for branch in experiment.branches:
+            if branch.status != "pending":
+                continue
+
+            # Compile plan from semantic move when branch doesn't carry one
+            if branch.compiled_plan is None and branch.move_id:
+                move = registry.get_move(branch.move_id)
+                if move is None:
+                    branch.status = "failed"
+                    continue
+                session_info = ableton.send_command("get_session_info")
+                kernel = {"session_info": session_info, "mode": "explore"}
+                plan = compiler.compile(move, kernel)
+                branch.compiled_plan = plan.to_dict()
+
+            if branch.compiled_plan is None:
+                branch.status = "failed"
+                continue
+
+            await exp_engine.run_branch_async(
+                branch=branch,
+                ableton=ableton,
+                compiled_plan=branch.compiled_plan,
+                capture_fn=capture_fn,
+                bridge=bridge,
+                mcp_registry=mcp_registry,
+                ctx=ctx,
+            )
+
+            def eval_fn(before, after):
+                score_result = engine.compute_evaluation_score(goal, before, after)
+                outcome = classify_branch_outcome(
+                    score=score_result.get("score", 0.0),
+                    protection_violated=not score_result.get("keep_change", True)
+                    and "protected" in " ".join(score_result.get("notes", [])).lower(),
+                    measurable_count=0,
+                    target_count=0,
+                    goal_progress=score_result.get("goal_progress", 0.0),
+                    exploration_rules=False,
+                )
+                return {
+                    "score": outcome.score,
+                    "keep_change": outcome.keep_change,
+                    "status": outcome.status,
+                    "note": outcome.note,
+                    "dimension_changes": score_result.get("dimension_changes", {}),
+                }
+
+            exp_engine.evaluate_branch(branch, eval_fn)
+            if branch.evaluation and branch.evaluation.get("status") == "keep":
+                branch.status = "evaluated"
+            elif branch.evaluation and branch.evaluation.get("status") == "undo":
+                branch.status = "rejected"
+
+        ranked = experiment.ranked_branches()
+        if not ranked:
+            return None, 0.0
+        top = ranked[0]
+        return top.branch_id, float(top.score or 0.0)
+
+    async def _commit(experiment_id: str, branch_id: str) -> dict:
+        return await exp_engine.commit_branch_async(
+            exp_engine.get_experiment(experiment_id),
+            branch_id,
+            ableton,
+            bridge=bridge,
+            mcp_registry=mcp_registry,
+            ctx=ctx,
+        )
+
+    async def _discard(experiment_id: str) -> dict:
+        return exp_engine.discard_experiment(experiment_id)
+
+    result = await iterate_toward_goal_engine_async(
+        candidate_move_sets=candidate_move_sets,
+        threshold=float(threshold),
+        max_iterations=int(max_iterations),
+        create_experiment_fn=_create,
+        run_experiment_fn=_run,
+        commit_fn=_commit,
+        discard_fn=_discard,
+        on_timeout=on_timeout,
+    )
+    return result.to_dict()

package/mcp_server/tools/analyzer.py

@@ -214,11 +214,24 @@ async def get_master_spectrum(
     samples: int = 0,
     sub_detail: bool = False,
 ) -> dict:
-    """Get 8-band frequency analysis of the master bus.
-
-    Returns band energies: sub (20-60Hz), low (60-200Hz), low_mid (200-500Hz),
-    mid (500-2kHz), high_mid (2-4kHz), high (4-8kHz), presence (8-12kHz),
-    air (12-20kHz). Values 0.0-1.0.
+    """Get 9-band frequency analysis of the master bus.
+
+    Returns band energies (fffb~ center frequencies shown in parens):
+      sub_low   20-60 Hz   (~35 Hz center)  — kick fundamentals, Villalobos subs
+      sub       60-120 Hz  (~85 Hz)         — 808s, sub-bass body
+      low       120-250 Hz (~175 Hz)        — bass body, warmth
+      low_mid   250-500 Hz (~350 Hz)        — mud zone, male vocal lows
+      mid       500-1 kHz  (~700 Hz)        — vocal presence, snare body
+      high_mid  1-2 kHz    (~1.4 kHz)       — consonants, pick attack
+      high      2-4 kHz    (~2.8 kHz)       — presence, vocal intelligibility
+      presence  4-8 kHz    (~5.6 kHz)       — cymbal definition, air of breath
+      air       8-20 kHz   (~12 kHz)        — shimmer, sparkle
+    Values 0.0-1.0.
+
+    Older .amxd builds (pre-v1.16) emit the legacy 8-band layout without the
+    explicit `sub_low` split — the server auto-detects band count from the OSC
+    payload and picks the right name set. Re-freeze the Max device to get the
+    9-band resolution.
 
     Also returns detected key/scale if enough audio has been analyzed.
     Requires LivePilot Analyzer on master track.
@@ -242,7 +255,7 @@ async def get_master_spectrum(
       Pass `sub_detail=True` to attach a `sub_detail` dict with three
       finer buckets: `sub_deep` (20-45 Hz), `sub_mid` (45-60 Hz),
       `sub_high` (60-80 Hz). Derived from the FluCoMa mel spectrum
-      (40 bands) rather than the 8-band cache, so it requires FluCoMa
+      (40 bands) rather than the 9-band cache, so it requires FluCoMa
       to be active. When FluCoMa is unavailable, sub_detail is omitted
       with a `sub_detail_warning` field explaining why.
     """

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "livepilot",
-  "version": "1.17.1",
+  "version": "1.17.2",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 426 tools, 52 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 — 427 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.17.1"
+__version__ = "1.17.2"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/requirements.txt

@@ -2,18 +2,18 @@
 numpy>=1.24.0
 fastmcp>=3.0.0,<3.3.0  # pinned upper bound — _get_all_tools() accesses private internals
 midiutil>=1.2.1
-pretty_midi>=0.2.10
+pretty_midi>=0.2.11
 # v1.8 Perception Layer (offline analysis)
-pyloudnorm>=0.1.0
-soundfile>=0.12.0
-scipy>=1.11.0
+pyloudnorm>=0.2.0
+soundfile>=0.13.1
+scipy>=1.17.1
 mutagen>=1.47.0
 # v1.10.5 Splice online catalog integration — required, not optional.
 # Without these, SpliceGRPCClient silently disables itself and search_samples
 # falls back to the SQLite sounds.db which only returns locally downloaded
 # samples (see docs/2026-04-14-bugs-discovered.md — P0-2).
 grpcio>=1.60.0
-protobuf>=4.25.0
+protobuf>=7.34.1
 
 # Development / testing (not required for runtime)
 # pip install pytest pytest-asyncio

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": "426-tool agentic MCP production system for Ableton Live 12 — device atlas, sample engine, composer",
+  "description": "427-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.17.1",
+  "version": "1.17.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.17.1",
+      "version": "1.17.2",
       "transport": {
         "type": "stdio"
       }