livepilot 1.17.0 → 1.17.2

package/mcp_server/preview_studio/tools.py

@@ -270,7 +270,68 @@ async def commit_preview_variant(
     if not ps:
         return {"error": f"Preview set {set_id} not found"}
 
+    # 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 {
+            "error": f"Variant {variant_id} not found in set {set_id}",
+            "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."
+            ),
+        }
+
+    # Only now do we flip state — the chosen variant has an executable plan.
     chosen = engine.commit_variant(ps, variant_id)
+    # engine.commit_variant cannot return None here (we already verified
+    # the variant_id exists), but keep the defensive check for the type
+    # checker.
     if not chosen:
         available = [v.variant_id for v in ps.variants]
         return {
@@ -289,55 +350,44 @@ 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
+
+    if steps_failed == 0 and steps_ok > 0:
+        result["status"] = "committed"
+    elif steps_ok > 0:
+        result["status"] = "committed_with_errors"
     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", {})
-
-        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
+        result["status"] = "failed"
+        result["committed"] = False
 
     # Wonder lifecycle hooks
     ws = _find_wonder_session_by_preview(set_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,

package/mcp_server/sample_engine/tools.py

@@ -259,14 +259,10 @@ async def search_samples(
     # Splice search — prefer gRPC online catalog when available, fall back
     # to local SQLite index. See docs/2026-04-14-bugs-discovered.md — P0-2.
     if source in (None, "splice"):
-        grpc_client = None
-        try:
-            grpc_client = ctx.lifespan_context.get("splice_client")
-        except AttributeError:
-            grpc_client = None
+        grpc_client = await _ensure_splice_client_connected(ctx)
 
         used_grpc = False
-        if grpc_client is not None and getattr(grpc_client, "connected", False):
+        if grpc_client is not None:
             try:
                 grpc_result = await grpc_client.search_samples(
                     query=query,
@@ -712,6 +708,43 @@ _SPLICE_USER_LIB_DEST = "~/Music/Ableton/User Library/Samples/Splice"
 _SPLICE_PREVIEW_CACHE = "~/Library/Caches/LivePilot/splice_previews"
 
 
+def _get_splice_client_from_context(ctx: Context):
+    """Return the shared Splice client from lifespan context when present."""
+    try:
+        return ctx.lifespan_context.get("splice_client")
+    except AttributeError:
+        return None
+
+
+async def _ensure_splice_client_connected(ctx: Context):
+    """Reconnect the shared Splice client on demand.
+
+    The MCP server creates one long-lived client during startup. If that
+    first handshake races or Splice launches later, the old behavior kept
+    every tool stuck in a disconnected state until the whole MCP server
+    restarted. Re-check here so tool results reflect current desktop state.
+    """
+    client = _get_splice_client_from_context(ctx)
+    if client is None:
+        return None
+    if getattr(client, "connected", False):
+        return client
+
+    connect = getattr(client, "connect", None)
+    if connect is None:
+        return None
+
+    try:
+        await connect()
+    except Exception as exc:
+        logger.debug("Splice reconnect failed: %s", exc)
+        return None
+
+    if getattr(client, "connected", False):
+        return client
+    return None
+
+
 @mcp.tool()
 async def get_splice_credits(ctx: Context) -> dict:
     """Get the user's current Splice plan, credits, and daily sample quota.
@@ -745,15 +778,10 @@ async def get_splice_credits(ctx: Context) -> dict:
     from ..splice_client.models import PlanKind
     from ..splice_client.quota import get_tracker
 
-    client = None
-    try:
-        client = ctx.lifespan_context.get("splice_client")
-    except AttributeError:
-        pass
-
     quota_summary = get_tracker().summary()
+    client = await _ensure_splice_client_connected(ctx)
 
-    if client is None or not getattr(client, "connected", False):
+    if client is None:
         return {
             "connected": False,
             "username": "",
@@ -857,13 +885,8 @@ async def splice_catalog_hunt(
     Each sample entry contains `file_hash` which you can pass to
     `splice_download_sample` to trigger a download.
     """
-    client = None
-    try:
-        client = ctx.lifespan_context.get("splice_client")
-    except AttributeError:
-        pass
-
-    if client is None or not getattr(client, "connected", False):
+    client = await _ensure_splice_client_connected(ctx)
+    if client is None:
         return {
             "connected": False,
             "error": "Splice gRPC not connected",
@@ -970,13 +993,8 @@ async def splice_download_sample(
     """
     import shutil
 
-    client = None
-    try:
-        client = ctx.lifespan_context.get("splice_client")
-    except AttributeError:
-        pass
-
-    if client is None or not getattr(client, "connected", False):
+    client = await _ensure_splice_client_connected(ctx)
+    if client is None:
         return {
             "ok": False,
             "error": "Splice gRPC not connected",
@@ -1096,13 +1114,8 @@ async def splice_preview_sample(
     import urllib.request
     import urllib.error
 
-    client = None
-    try:
-        client = ctx.lifespan_context.get("splice_client")
-    except AttributeError:
-        pass
-
-    if client is None or not getattr(client, "connected", False):
+    client = await _ensure_splice_client_connected(ctx)
+    if client is None:
         return {"ok": False, "error": "Splice gRPC not connected"}
 
     # Two-stage lookup: SampleInfo is the fast path but only returns
@@ -1184,14 +1197,10 @@ async def splice_preview_sample(
 # ────────────────────────────────────────────────────────────────────────
 
 
-def _require_splice_client(ctx: Context) -> tuple[object, Optional[dict]]:
+async def _require_splice_client(ctx: Context) -> tuple[object, Optional[dict]]:
     """Fetch the Splice client from context, or return an error dict."""
-    client = None
-    try:
-        client = ctx.lifespan_context.get("splice_client")
-    except AttributeError:
-        pass
-    if client is None or not getattr(client, "connected", False):
+    client = await _ensure_splice_client_connected(ctx)
+    if client is None:
         return None, {"ok": False, "error": "Splice gRPC not connected"}
     return client, None
 
@@ -1215,7 +1224,7 @@ async def splice_list_collections(
       ],
     }
     """
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     total, collections = await client.list_collections(
@@ -1244,7 +1253,7 @@ async def splice_search_in_collection(
     `splice_catalog_hunt` — you can feed them straight into
     `splice_preview_sample` or `splice_download_sample`.
     """
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     total, samples = await client.collection_samples(
@@ -1271,7 +1280,7 @@ async def splice_add_to_collection(
     and web UI immediately. Use this to let LivePilot "save for later"
     items it finds during composition work.
     """
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     if not file_hashes:
@@ -1289,7 +1298,7 @@ async def splice_remove_from_collection(
     ctx: Context, collection_uuid: str, file_hashes: list[str],
 ) -> dict:
     """Remove one or more samples from a user Collection (server-side)."""
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     if not file_hashes:
@@ -1307,7 +1316,7 @@ async def splice_remove_from_collection(
 @mcp.tool()
 async def splice_create_collection(ctx: Context, name: str) -> dict:
     """Create a new user Collection. Returns the new UUID on success."""
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     name = (name or "").strip()
@@ -1347,7 +1356,7 @@ async def splice_list_presets(
       ],
     }
     """
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     total, presets = await client.list_purchased_presets(
@@ -1371,7 +1380,7 @@ async def splice_preset_info(
     plugin_name: str = "",
 ) -> dict:
     """Fetch metadata for a single preset (uuid, file_hash, or plugin_name)."""
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     if not (uuid or file_hash or plugin_name):
@@ -1394,7 +1403,7 @@ async def splice_download_preset(ctx: Context, uuid: str) -> dict:
     """
     from ..splice_client.client import CREDIT_HARD_FLOOR
 
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     if not uuid:
@@ -1437,7 +1446,7 @@ async def splice_pack_info(ctx: Context, pack_uuid: str) -> dict:
     Useful for discovering related samples by pack, or surfacing pack-level
     genre/provider info that search results omit.
     """
-    client, err = _require_splice_client(ctx)
+    client, err = await _require_splice_client(ctx)
     if err:
         return err
     if not pack_uuid:
@@ -1469,19 +1478,15 @@ async def splice_pack_info(ctx: Context, pack_uuid: str) -> dict:
 # ────────────────────────────────────────────────────────────────────────
 
 
-def _build_http_bridge(ctx: Context):
+async def _build_http_bridge(ctx: Context):
     """Construct the HTTPS bridge with the current gRPC client attached.
 
     Returns (bridge, err_dict). On success err_dict is None.
     """
     from ..splice_client.http_bridge import SpliceHTTPBridge
 
-    client = None
-    try:
-        client = ctx.lifespan_context.get("splice_client")
-    except AttributeError:
-        pass
-    if client is None or not getattr(client, "connected", False):
+    client = await _ensure_splice_client_connected(ctx)
+    if client is None:
         return None, {
             "ok": False,
             "error": "Splice gRPC not connected — session token unreachable",
@@ -1520,7 +1525,7 @@ async def splice_describe_sound(
     instrument/tags/pack_name/files. Use the uuid with
     `splice_download_sample(uuid)` to pull the audio file.
     """
-    bridge, err = _build_http_bridge(ctx)
+    bridge, err = await _build_http_bridge(ctx)
     if err:
         return err
     from ..splice_client.http_bridge import SpliceHTTPError
@@ -1572,7 +1577,7 @@ async def splice_generate_variation(
     duration/tags/pack_name/files). Use the uuid of any result with
     `splice_download_sample()` to pull the audio.
     """
-    bridge, err = _build_http_bridge(ctx)
+    bridge, err = await _build_http_bridge(ctx)
     if err:
         return err
     from ..splice_client.http_bridge import SpliceHTTPError
@@ -1631,12 +1636,8 @@ async def splice_http_diagnose(ctx: Context) -> dict:
     # diagnostic is worse than no diagnostic.
     session_token_available = False
     session_token_error = None
-    grpc_client = None
-    try:
-        grpc_client = ctx.lifespan_context.get("splice_client")
-    except AttributeError:
-        pass
-    if grpc_client is None or not getattr(grpc_client, "connected", False):
+    grpc_client = await _ensure_splice_client_connected(ctx)
+    if grpc_client is None:
         session_token_error = "Splice gRPC not connected"
     else:
         # Connection is up; confirm a token actually comes back.

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(),
     }