livepilot 1.17.1 → 1.17.3

package/mcp_server/preview_studio/tools.py

@@ -270,7 +270,15 @@ async def commit_preview_variant(
     if not ps:
         return {"error": f"Preview set {set_id} not found"}
 
-    chosen = engine.commit_variant(ps, variant_id)
+    # Resolve the chosen variant WITHOUT mutating state yet. We have to
+    # short-circuit analytical-only / blocked picks BEFORE engine.commit_variant
+    # runs, otherwise `preview_set.status` gets flipped to "committed" and
+    # sibling variants get discarded even though nothing executed.
+    chosen = None
+    for v in ps.variants:
+        if v.variant_id == variant_id:
+            chosen = v
+            break
     if not chosen:
         available = [v.variant_id for v in ps.variants]
         return {
@@ -278,8 +286,58 @@ async def commit_preview_variant(
             "available_variants": available,
         }
 
+    # ── Truth-gap guard: refuse to "commit" a variant that can't execute ──
+    # If the variant was flagged blocked/failed upstream or lacks a
+    # compiled plan, the old code still marked preview_set.status='committed'
+    # and returned committed=False as a silent contradiction. Close that
+    # gap: return an honest no-op and leave state untouched so the caller
+    # can pick a different variant.
+    plan = chosen.compiled_plan
+    plan_is_empty = (
+        plan is None
+        or (isinstance(plan, list) and len(plan) == 0)
+        or (isinstance(plan, dict) and len(plan.get("steps") or []) == 0)
+    )
+    blocked = chosen.status in {"blocked", "failed"}
+    if plan_is_empty or blocked:
+        reason = "blocked" if blocked and plan_is_empty is False else "analytical_only"
+        return {
+            "committed": False,
+            "status": "analytical_only" if reason == "analytical_only" else "blocked",
+            "reason": reason,
+            "preview_set_id": set_id,
+            "variant_id": chosen.variant_id,
+            "label": chosen.label,
+            "intent": chosen.intent,
+            "move_id": chosen.move_id,
+            "identity_effect": chosen.identity_effect,
+            "what_preserved": chosen.what_preserved,
+            "message": (
+                "chose analytical variant; no session changes applied"
+                if reason == "analytical_only"
+                else "variant is blocked; no session changes applied"
+            ),
+            "note": (
+                "Variant has no compiled plan (analytical-only). Preview set "
+                "was left in its pre-commit state so you can pick a different "
+                "variant."
+                if reason == "analytical_only"
+                else "Variant is blocked/failed. Preview set was left in its "
+                "pre-commit state so you can pick a different variant."
+            ),
+        }
+
+    # ── P1#2 fix (v1.17.3): execute BEFORE flipping state ──
+    # Prior behavior: engine.commit_variant() ran here, BEFORE execution.
+    # If every step then failed, the returned payload correctly said
+    # committed=False / status='failed' — but preview_set.status was
+    # already "committed" and Wonder lifecycle advance fired regardless.
+    # Response and stored state contradicted each other.
+    #
+    # New flow: we already have `chosen` from the resolution block above.
+    # Execute the plan first, count successes, THEN flip state only when
+    # at least one step actually applied. Zero successes = honest no-op.
     result = {
-        "committed": True,
         "variant_id": chosen.variant_id,
         "label": chosen.label,
         "intent": chosen.intent,
@@ -289,57 +347,55 @@ async def commit_preview_variant(
     }
 
     # ── v1.10.3: actually execute the compiled plan ──
-    # If there's no compiled plan, the variant is analytical-only — record
-    # the choice and return honestly instead of pretending it was applied.
-    if not chosen.compiled_plan:
-        result["committed"] = False
-        result["status"] = "analytical_only"
-        result["note"] = (
-            "Variant has no compiled plan (analytical-only). Preview set "
-            "marked the choice but no session changes were made. Use an "
-            "executable variant if you want the commit to apply changes."
-        )
+    from ..runtime.execution_router import execute_plan_steps_async
+    plan = chosen.compiled_plan
+    steps = plan if isinstance(plan, list) else plan.get("steps", []) or []
+    ableton = _get_ableton(ctx)
+    bridge = ctx.lifespan_context.get("m4l")
+    mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
+
+    exec_results = await execute_plan_steps_async(
+        steps,
+        ableton=ableton,
+        bridge=bridge,
+        mcp_registry=mcp_registry,
+        ctx=ctx,
+        stop_on_failure=False,
+    )
+    log = [
+        {
+            "tool": r.tool,
+            "backend": r.backend,
+            "ok": r.ok,
+            **({"result": r.result} if r.ok else {"error": r.error}),
+        }
+        for r in exec_results
+    ]
+    steps_ok = sum(1 for r in exec_results if r.ok)
+    steps_failed = len(exec_results) - steps_ok
+
+    result["execution_log"] = log
+    result["steps_ok"] = steps_ok
+    result["steps_failed"] = steps_failed
+
+    # ── P1#2: only flip preview-set state when at least one step succeeded ──
+    if steps_failed == 0 and steps_ok > 0:
+        result["status"] = "committed"
+        result["committed"] = True
+        engine.commit_variant(ps, variant_id)
+    elif steps_ok > 0:
+        result["status"] = "committed_with_errors"
+        result["committed"] = True  # partial but real commit
+        engine.commit_variant(ps, variant_id)
     else:
-        from ..runtime.execution_router import execute_plan_steps_async
-        plan = chosen.compiled_plan
-        steps = plan if isinstance(plan, list) else plan.get("steps", []) or []
-        ableton = _get_ableton(ctx)
-        bridge = ctx.lifespan_context.get("m4l")
-        mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
+        # Every step failed — do NOT flip preview-set state, do NOT advance
+        # Wonder. The response already reflects the failure; the stored
+        # state must agree.
+        result["status"] = "failed"
+        result["committed"] = False
+        return result
 
-        exec_results = await execute_plan_steps_async(
-            steps,
-            ableton=ableton,
-            bridge=bridge,
-            mcp_registry=mcp_registry,
-            ctx=ctx,
-            stop_on_failure=False,
-        )
-        log = [
-            {
-                "tool": r.tool,
-                "backend": r.backend,
-                "ok": r.ok,
-                **({"result": r.result} if r.ok else {"error": r.error}),
-            }
-            for r in exec_results
-        ]
-        steps_ok = sum(1 for r in exec_results if r.ok)
-        steps_failed = len(exec_results) - steps_ok
-
-        result["execution_log"] = log
-        result["steps_ok"] = steps_ok
-        result["steps_failed"] = steps_failed
-
-        if steps_failed == 0 and steps_ok > 0:
-            result["status"] = "committed"
-        elif steps_ok > 0:
-            result["status"] = "committed_with_errors"
-        else:
-            result["status"] = "failed"
-            result["committed"] = False
-
-    # Wonder lifecycle hooks
+    # Wonder lifecycle hooks — only reached when steps_ok > 0.
     ws = _find_wonder_session_by_preview(set_id)
     if ws:
         ws.selected_variant_id = variant_id

package/mcp_server/runtime/capability_state.py

@@ -155,6 +155,9 @@ def build_capability_state(
     )
 
     # ── web ──────────────────────────────────────────────────────────
+    # Server-side outbound HTTP capability.  True when the MCP host can
+    # reach an arbitrary public URL.  Does NOT imply curated research
+    # corpora are installed — see the ``research`` domain below.
     web_reasons: list[str] = []
     if not web_ok:
         web_reasons.append("web_unavailable")
@@ -166,6 +169,21 @@ def build_capability_state(
         reasons=web_reasons,
     )
 
+    # ── flucoma ──────────────────────────────────────────────────────
+    # Optional dependency (the ``flucoma`` Python package).  Emitted
+    # unconditionally so consumers can distinguish "probed and missing"
+    # from "probe not run yet".
+    flucoma_reasons: list[str] = []
+    if not flucoma_ok:
+        flucoma_reasons.append("flucoma_not_installed")
+    domains["flucoma"] = CapabilityDomain(
+        name="flucoma",
+        available=flucoma_ok,
+        confidence=0.9 if flucoma_ok else 0.0,
+        mode="available" if flucoma_ok else "unavailable",
+        reasons=flucoma_reasons,
+    )
+
     # ── research (composite) ────────────────────────────────────────
     research_reasons: list[str] = []
     research_sources = 0

package/mcp_server/runtime/degradation.py

@@ -0,0 +1,62 @@
+"""Explicit degradation signalling for engines that fall back to synthesized data.
+
+Before PR-B, several engines silently substituted defaults when a data
+source failed — ``song_brain`` injected ``tempo=120.0, track_count=0``
+on session-fetch failure, and ``preview_studio`` compiled variants
+against an empty-but-valid kernel when the caller didn't supply one.
+Downstream consumers had no way to tell synthesized data from real
+data, so polished outputs were returned as if they were real.
+
+``DegradationInfo`` is the shared payload engines attach to their
+responses whenever they substitute fallback values. Consumers can
+inspect ``is_degraded``, ``reasons``, and ``substituted_fields`` to
+decide whether to trust the response or re-try the operation.
+
+Usage::
+
+    from mcp_server.runtime.degradation import DegradationInfo
+
+    deg = DegradationInfo()
+    try:
+        data = fetch_real_data()
+    except Exception:
+        data = FALLBACK_DATA
+        deg = DegradationInfo(
+            is_degraded=True,
+            reasons=["data_source_unreachable"],
+            substituted_fields=["tempo", "track_count"],
+        )
+    return {..., "degradation": deg.to_dict()}
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DegradationInfo:
+    """A structured signal that an engine substituted fallback data.
+
+    Attributes:
+        is_degraded: True when any field in the response was substituted
+            with a synthesized/default value. False means the response
+            is fully backed by real data sources.
+        reasons: Short machine-readable tokens describing why degradation
+            happened (e.g., ``"session_fetch_failed"``,
+            ``"empty_kernel_fallback"``). Intentionally open-ended — the
+            set grows as new fallback paths get flagged.
+        substituted_fields: Names of top-level response fields whose
+            values came from the fallback path, not the real source.
+    """
+
+    is_degraded: bool = False
+    reasons: list[str] = field(default_factory=list)
+    substituted_fields: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "is_degraded": self.is_degraded,
+            "reasons": list(self.reasons),
+            "substituted_fields": list(self.substituted_fields),
+        }

package/mcp_server/runtime/tools.py

@@ -7,6 +7,9 @@ Tools:
 
 from __future__ import annotations
 
+import importlib.util
+import logging
+import urllib.request
 from typing import Optional
 
 from fastmcp import Context
@@ -14,13 +17,55 @@ from fastmcp import Context
 from ..server import mcp
 from ..memory.technique_store import TechniqueStore
 from .capability_state import build_capability_state
-import logging
 
 logger = logging.getLogger(__name__)
 
 _memory_store = TechniqueStore()
 
 
+# ── Capability probes ──────────────────────────────────────────────────
+#
+# These helpers are module-level so tests can monkeypatch them directly.
+
+
+def _probe_web(timeout: float = 0.5) -> bool:
+    """Server-side outbound HTTP probe.
+
+    True when the MCP host can reach an arbitrary public URL. Does NOT
+    imply curated research corpora are installed — see the ``research``
+    domain for that.
+
+    Implementation: a ``timeout``-second HEAD request to
+    ``https://api.github.com`` using stdlib ``urllib.request``. Any
+    exception (DNS failure, TLS error, socket timeout, proxy block,
+    non-2xx response) collapses to False so the probe is safe to call
+    from any code path.
+    """
+    req = urllib.request.Request("https://api.github.com", method="HEAD")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            status = getattr(resp, "status", None)
+            return status is not None and 200 <= status < 400
+    except Exception as exc:  # noqa: BLE001 — swallow everything to False
+        logger.debug("_probe_web failed: %s", exc)
+        return False
+
+
+def _probe_flucoma() -> bool:
+    """Check whether the ``flucoma`` Python package is importable.
+
+    Uses ``importlib.util.find_spec`` so no import side-effects fire
+    (matching the pattern already used for optional capability probes
+    elsewhere in the codebase). Returns False if the package is missing
+    or if the spec lookup itself raises.
+    """
+    try:
+        return importlib.util.find_spec("flucoma") is not None
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("_probe_flucoma failed: %s", exc)
+        return False
+
+
 @mcp.tool()
 def get_capability_state(ctx: Context) -> dict:
     """Probe the runtime and return a capability state snapshot.
@@ -59,9 +104,13 @@ def get_capability_state(ctx: Context) -> dict:
         logger.debug("get_capability_state failed: %s", exc)
         memory_ok = False
 
-    # ── Web / FluCoMa — not probed live, default to False ───────────
-    web_ok = False
-    flucoma_ok = False
+    # ── Web — actually probe outbound HTTP egress ───────────────────
+    # Scoped to server-side outbound HTTP reachability; does NOT imply
+    # a curated research corpus is installed (see ``research`` domain).
+    web_ok = _probe_web()
+
+    # ── FluCoMa — optional import via find_spec (no side effects) ───
+    flucoma_ok = _probe_flucoma()
 
     state = build_capability_state(
         session_ok=session_ok,
@@ -130,11 +179,19 @@ def get_session_kernel(
         if analyzer_ok:
             analyzer_fresh = spectral.get("spectrum") is not None
 
+    # P2#3 (v1.17.3): probe web + flucoma the same way get_capability_state
+    # does, and propagate through. Without this the kernel's capability view
+    # lies to orchestration planners.
+    web_ok = _probe_web()
+    flucoma_ok = _probe_flucoma()
+
     state = build_capability_state(
         session_ok=session_ok,
         analyzer_ok=analyzer_ok,
         analyzer_fresh=analyzer_fresh,
         memory_ok=True,
+        web_ok=web_ok,
+        flucoma_ok=flucoma_ok,
     )
 
     # Optional subcomponents — degrade gracefully, but reach into the SAME

package/mcp_server/song_brain/tools.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 from fastmcp import Context
 
+from ..runtime.degradation import DegradationInfo
 from ..server import mcp
 from . import builder
 from .models import SongBrain
@@ -55,6 +56,12 @@ def _fetch_session_data(ctx: Context) -> dict:
     - composition_analysis: from musical intelligence section inference
     - role_graph: from semantic move resolvers (track role inference)
     - recent_moves: from session-scoped action ledger
+
+    On session-fetch failure the fallback session_info shape is injected
+    (``tempo=120.0, track_count=0``) and a ``DegradationInfo`` is attached
+    under the ``_degradation`` key so callers can tell synthesized data
+    from real data. ``_fetch_session_data`` never raises — it always
+    returns a dict with the expected keys.
     """
     ableton = _get_ableton(ctx)
     data: dict = {
@@ -66,12 +73,19 @@ def _fetch_session_data(ctx: Context) -> dict:
         "role_graph": {},
         "recent_moves": [],
     }
+    degradation = DegradationInfo()
 
     try:
         data["session_info"] = ableton.send_command("get_session_info", {})
     except Exception as exc:
         logger.debug("_fetch_session_data failed: %s", exc)
         data["session_info"] = {"tempo": 120.0, "track_count": 0}
+        degradation.is_degraded = True
+        if "session_fetch_failed" not in degradation.reasons:
+            degradation.reasons.append("session_fetch_failed")
+        for fld in ("tempo", "track_count"):
+            if fld not in degradation.substituted_fields:
+                degradation.substituted_fields.append(fld)
 
     try:
         matrix = ableton.send_command("get_scene_matrix")
@@ -135,6 +149,10 @@ def _fetch_session_data(ctx: Context) -> dict:
     except Exception as exc:
         logger.debug("_fetch_session_data failed: %s", exc)
 
+    # Attach the degradation signal so build_song_brain can surface it.
+    # Under a reserved key (leading underscore) so it never collides with
+    # a real session data field.
+    data["_degradation"] = degradation
     return data
 
 
@@ -180,10 +198,15 @@ def build_song_brain(ctx: Context) -> dict:
     )
     _set_brain(ctx, brain)
 
+    # Surface the degradation payload so callers can distinguish a
+    # tempo=120 / track_count=0 synthesized response from a real one.
+    degradation = data.get("_degradation") or DegradationInfo()
+
     return {
         **brain.to_dict(),
         "summary": brain.summary,
         "capability": cap.to_dict(),
+        "degradation": degradation.to_dict(),
     }
 
 

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",
 ]