livepilot 1.17.0 → 1.17.2

package/mcp_server/synthesis_brain/timbre.py

@@ -19,12 +19,16 @@ from .models import TimbralFingerprint
 
 # ── Band-based brightness / warmth mapping ──────────────────────────────
 #
-# The M4L analyzer returns an 8-band spectrum by default. When a full
-# spectrum dict is passed, we look for these band keys in order. If the
-# raw {freq: magnitude} shape is passed instead, we fall back to a coarser
-# low/mid/high split.
+# Two upstream producers feed this extractor with different band schemas:
+#   1. get_master_spectrum (M4L analyzer)   — v1.16+: 9 bands (sub_low,
+#      sub, low, low_mid, mid, high_mid, high, presence, air);
+#      pre-v1.16: 8 bands (no sub_low).
+#   2. analyze_spectrum_offline             — 8 bands with legacy names
+#      (sub, low, low_mid, mid, high_mid, high, very_high, ultra).
+# We index the union of both name sets below; `_band_energy` uses dict.get
+# so missing bands simply return 0 without complaint.
 
-_BANDS = ("sub", "low", "low_mid", "mid", "high_mid", "high", "very_high", "ultra")
+_BANDS = ("sub_low", "sub", "low", "low_mid", "mid", "high_mid", "high", "presence", "air", "very_high", "ultra")
 
 
 def _band_energy(spectrum: Optional[dict], band: str) -> float:
@@ -55,9 +59,11 @@ def extract_timbre_fingerprint(
     Inputs are all optional — the function degrades gracefully when only
     some dimensions are measurable.
 
-      spectrum: either {sub, low, low_mid, mid, high_mid, high, very_high, ultra}
-        or {"bands": {...}} — the 8-band shape returned by get_master_spectrum /
-        analyze_spectrum_offline. Missing bands default to 0.
+      spectrum: either the 9-band shape from get_master_spectrum
+        ({sub_low, sub, low, low_mid, mid, high_mid, high, presence, air}),
+        the legacy 8-band shape from analyze_spectrum_offline
+        ({sub, low, low_mid, mid, high_mid, high, very_high, ultra}),
+        or {"bands": {...}} wrapping either. Missing bands default to 0.
       loudness: {"rms": float, "peak": float, "lufs": float, "lra": float} —
         output shape from analyze_loudness.
       spectral_shape: FluCoMa descriptors when available — {"centroid", "flatness",

package/mcp_server/tools/_agent_os_engine/__init__.py

@@ -35,6 +35,12 @@ from .taste import (
     compute_taste_fit,
     get_taste_profile,
 )
+from .iteration import (
+    iterate_toward_goal_engine,
+    iterate_toward_goal_engine_async,
+    IterationResult,
+    IterationStep,
+)
 
 __all__ = [
     "QUALITY_DIMENSIONS", "MEASURABLE_PROXIES",
@@ -49,4 +55,8 @@ __all__ = [
     "analyze_outcome_history",
     "compute_taste_fit",
     "get_taste_profile",
+    "iterate_toward_goal_engine",
+    "iterate_toward_goal_engine_async",
+    "IterationResult",
+    "IterationStep",
 ]

package/mcp_server/tools/_agent_os_engine/iteration.py

@@ -0,0 +1,344 @@
+"""Iteration engine — closes the evaluation loop by running experiments
+repeatedly against a compiled GoalVector until threshold or timeout.
+
+Pure-python: takes callables for experiment create/run/commit/discard so
+tests can substitute in-memory fakes without an Ableton connection. The
+callables may be sync or async — the engine uses `iterate_toward_goal_engine`
+(sync) for the former and `iterate_toward_goal_engine_async` for the latter.
+"""
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Optional, Union
+
+
+@dataclass
+class IterationStep:
+    """One iteration of the outer loop — one experiment's worth of work."""
+    iteration: int
+    experiment_id: str
+    winner_branch_id: Optional[str]
+    winner_score: float
+    threshold_met: bool
+    note: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "iteration": self.iteration,
+            "experiment_id": self.experiment_id,
+            "winner_branch_id": self.winner_branch_id,
+            "winner_score": self.winner_score,
+            "threshold_met": self.threshold_met,
+            "note": self.note,
+        }
+
+
+@dataclass
+class IterationResult:
+    """Final result of iterate_toward_goal.
+
+    status:
+      - "committed" — a winner hit threshold, was committed permanently
+      - "exhausted" — max_iterations reached, committed best-so-far (on_timeout=commit_best)
+      - "timeout_no_commit" — max_iterations reached, no commit (on_timeout=discard_on_timeout)
+      - "no_candidates" — caller provided empty candidate_move_sets
+      - "error" — unrecoverable error; see reason
+    """
+    status: str
+    iterations_run: int
+    committed_experiment_id: Optional[str]
+    committed_branch_id: Optional[str]
+    final_score: float
+    steps: list[IterationStep] = field(default_factory=list)
+    reason: str = ""
+
+    def to_dict(self) -> dict:
+        return {
+            "status": self.status,
+            "iterations_run": self.iterations_run,
+            "committed_experiment_id": self.committed_experiment_id,
+            "committed_branch_id": self.committed_branch_id,
+            "final_score": self.final_score,
+            "steps": [s.to_dict() for s in self.steps],
+            "reason": self.reason,
+        }
+
+
+def iterate_toward_goal_engine(
+    candidate_move_sets: list,
+    threshold: float,
+    max_iterations: int,
+    create_experiment_fn: Callable[[list], str],
+    run_experiment_fn: Callable[[str], Any],
+    commit_fn: Callable[[str, str], dict],
+    discard_fn: Callable[[str], dict],
+    on_timeout: str = "commit_best",
+) -> IterationResult:
+    """Run experiments repeatedly until winner_score >= threshold or timeout.
+
+    Pure orchestration — all I/O happens through the injected callbacks. The
+    run/commit/discard callbacks may be sync or async; coroutines will be
+    awaited when reached. This keeps the engine reusable by both the
+    sync test suite and the async MCP tool wrapper.
+
+    See module docstring for full contract. Invariant: never issues raw
+    undo calls — per-branch undo is the responsibility of run_experiment_fn.
+    This loop only chooses commit vs discard.
+    """
+    import asyncio
+
+    async def _as_async():
+        return await _iterate_async_core(
+            candidate_move_sets=candidate_move_sets,
+            threshold=threshold,
+            max_iterations=max_iterations,
+            create_experiment_fn=create_experiment_fn,
+            run_experiment_fn=run_experiment_fn,
+            commit_fn=commit_fn,
+            discard_fn=discard_fn,
+            on_timeout=on_timeout,
+        )
+
+    # If any callback is a coroutine function, run via asyncio. Otherwise
+    # execute the sync path directly to avoid event-loop overhead in tests.
+    any_async = any(
+        inspect.iscoroutinefunction(fn)
+        for fn in (create_experiment_fn, run_experiment_fn, commit_fn, discard_fn)
+    )
+    if any_async:
+        return asyncio.run(_as_async())
+
+    return _iterate_sync_core(
+        candidate_move_sets=candidate_move_sets,
+        threshold=threshold,
+        max_iterations=max_iterations,
+        create_experiment_fn=create_experiment_fn,
+        run_experiment_fn=run_experiment_fn,
+        commit_fn=commit_fn,
+        discard_fn=discard_fn,
+        on_timeout=on_timeout,
+    )
+
+
+async def iterate_toward_goal_engine_async(
+    candidate_move_sets: list,
+    threshold: float,
+    max_iterations: int,
+    create_experiment_fn: Callable[[list], Any],
+    run_experiment_fn: Callable[[str], Any],
+    commit_fn: Callable[[str, str], Any],
+    discard_fn: Callable[[str], Any],
+    on_timeout: str = "commit_best",
+) -> IterationResult:
+    """Async variant — used by the MCP tool wrapper which has async callbacks."""
+    return await _iterate_async_core(
+        candidate_move_sets=candidate_move_sets,
+        threshold=threshold,
+        max_iterations=max_iterations,
+        create_experiment_fn=create_experiment_fn,
+        run_experiment_fn=run_experiment_fn,
+        commit_fn=commit_fn,
+        discard_fn=discard_fn,
+        on_timeout=on_timeout,
+    )
+
+
+# ── Internal cores ─────────────────────────────────────────────────────────
+
+def _iterate_sync_core(
+    candidate_move_sets,
+    threshold,
+    max_iterations,
+    create_experiment_fn,
+    run_experiment_fn,
+    commit_fn,
+    discard_fn,
+    on_timeout,
+) -> IterationResult:
+    if not candidate_move_sets:
+        return IterationResult(
+            status="no_candidates",
+            iterations_run=0,
+            committed_experiment_id=None,
+            committed_branch_id=None,
+            final_score=0.0,
+            reason="candidate_move_sets is empty",
+        )
+
+    steps: list[IterationStep] = []
+    best_score = -1.0
+    best_exp_id: Optional[str] = None
+    best_branch_id: Optional[str] = None
+    n = min(max_iterations, len(candidate_move_sets))
+
+    for i in range(n):
+        move_ids = candidate_move_sets[i]
+        exp_id = create_experiment_fn(move_ids)
+        winner_branch_id, winner_score = run_experiment_fn(exp_id)
+
+        met = winner_score >= threshold and winner_branch_id is not None
+        steps.append(IterationStep(
+            iteration=i,
+            experiment_id=exp_id,
+            winner_branch_id=winner_branch_id,
+            winner_score=winner_score,
+            threshold_met=met,
+            note=(
+                f"committed on iteration {i}" if met
+                else f"below threshold (need {threshold}, got {winner_score})"
+            ),
+        ))
+
+        if met:
+            # Discard any prior best-so-far before committing the new winner —
+            # otherwise the old non-winning experiment leaks in the store.
+            if best_exp_id is not None and best_exp_id != exp_id:
+                discard_fn(best_exp_id)
+            commit_fn(exp_id, winner_branch_id)
+            return IterationResult(
+                status="committed",
+                iterations_run=i + 1,
+                committed_experiment_id=exp_id,
+                committed_branch_id=winner_branch_id,
+                final_score=winner_score,
+                steps=steps,
+                reason=f"threshold {threshold} met on iteration {i}",
+            )
+
+        if winner_branch_id is not None and winner_score > best_score:
+            # Supersede previous best-so-far. It's now stale, free the slot.
+            if best_exp_id is not None:
+                discard_fn(best_exp_id)
+            best_score = winner_score
+            best_exp_id = exp_id
+            best_branch_id = winner_branch_id
+        else:
+            discard_fn(exp_id)
+
+    if on_timeout == "commit_best" and best_exp_id and best_branch_id:
+        commit_fn(best_exp_id, best_branch_id)
+        return IterationResult(
+            status="exhausted",
+            iterations_run=n,
+            committed_experiment_id=best_exp_id,
+            committed_branch_id=best_branch_id,
+            final_score=best_score,
+            steps=steps,
+            reason=(
+                f"max_iterations={n} reached, threshold {threshold} never met; "
+                f"committed best-so-far with score {best_score}"
+            ),
+        )
+
+    if best_exp_id:
+        discard_fn(best_exp_id)
+    return IterationResult(
+        status="timeout_no_commit",
+        iterations_run=n,
+        committed_experiment_id=None,
+        committed_branch_id=None,
+        final_score=max(best_score, 0.0),
+        steps=steps,
+        reason=f"max_iterations={n} reached, policy={on_timeout}, no commit issued",
+    )
+
+
+async def _iterate_async_core(
+    candidate_move_sets,
+    threshold,
+    max_iterations,
+    create_experiment_fn,
+    run_experiment_fn,
+    commit_fn,
+    discard_fn,
+    on_timeout,
+) -> IterationResult:
+    if not candidate_move_sets:
+        return IterationResult(
+            status="no_candidates",
+            iterations_run=0,
+            committed_experiment_id=None,
+            committed_branch_id=None,
+            final_score=0.0,
+            reason="candidate_move_sets is empty",
+        )
+
+    async def _maybe_await(value):
+        if inspect.isawaitable(value):
+            return await value
+        return value
+
+    steps: list[IterationStep] = []
+    best_score = -1.0
+    best_exp_id: Optional[str] = None
+    best_branch_id: Optional[str] = None
+    n = min(max_iterations, len(candidate_move_sets))
+
+    for i in range(n):
+        move_ids = candidate_move_sets[i]
+        exp_id = await _maybe_await(create_experiment_fn(move_ids))
+        winner_branch_id, winner_score = await _maybe_await(run_experiment_fn(exp_id))
+
+        met = winner_score >= threshold and winner_branch_id is not None
+        steps.append(IterationStep(
+            iteration=i,
+            experiment_id=exp_id,
+            winner_branch_id=winner_branch_id,
+            winner_score=winner_score,
+            threshold_met=met,
+            note=(
+                f"committed on iteration {i}" if met
+                else f"below threshold (need {threshold}, got {winner_score})"
+            ),
+        ))
+
+        if met:
+            if best_exp_id is not None and best_exp_id != exp_id:
+                await _maybe_await(discard_fn(best_exp_id))
+            await _maybe_await(commit_fn(exp_id, winner_branch_id))
+            return IterationResult(
+                status="committed",
+                iterations_run=i + 1,
+                committed_experiment_id=exp_id,
+                committed_branch_id=winner_branch_id,
+                final_score=winner_score,
+                steps=steps,
+                reason=f"threshold {threshold} met on iteration {i}",
+            )
+
+        if winner_branch_id is not None and winner_score > best_score:
+            if best_exp_id is not None:
+                await _maybe_await(discard_fn(best_exp_id))
+            best_score = winner_score
+            best_exp_id = exp_id
+            best_branch_id = winner_branch_id
+        else:
+            await _maybe_await(discard_fn(exp_id))
+
+    if on_timeout == "commit_best" and best_exp_id and best_branch_id:
+        await _maybe_await(commit_fn(best_exp_id, best_branch_id))
+        return IterationResult(
+            status="exhausted",
+            iterations_run=n,
+            committed_experiment_id=best_exp_id,
+            committed_branch_id=best_branch_id,
+            final_score=best_score,
+            steps=steps,
+            reason=(
+                f"max_iterations={n} reached, threshold {threshold} never met; "
+                f"committed best-so-far with score {best_score}"
+            ),
+        )
+
+    if best_exp_id:
+        await _maybe_await(discard_fn(best_exp_id))
+    return IterationResult(
+        status="timeout_no_commit",
+        iterations_run=n,
+        committed_experiment_id=None,
+        committed_branch_id=None,
+        final_score=max(best_score, 0.0),
+        steps=steps,
+        reason=f"max_iterations={n} reached, policy={on_timeout}, no commit issued",
+    )

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.0",
+  "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.0"
+__version__ = "1.17.2"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router