livepilot 1.26.1 → 1.27.0

package/mcp_server/runtime/tools.py

@@ -7,10 +7,11 @@ Tools:
 
 from __future__ import annotations
 
-import importlib.util
 import logging
+import os
+from pathlib import Path
 import urllib.request
-from typing import Optional
+from typing import Any, Optional
 
 from fastmcp import Context
 
@@ -21,6 +22,14 @@ from .capability_state import build_capability_state
 logger = logging.getLogger(__name__)
 
 _memory_store = TechniqueStore()
+_FLUCOMA_STREAM_KEYS = (
+    "spectral_shape",
+    "mel_bands",
+    "chroma",
+    "onset",
+    "novelty",
+    "loudness",
+)
 
 
 # ── Capability probes ──────────────────────────────────────────────────
@@ -51,21 +60,296 @@ def _probe_web(timeout: float = 0.5) -> bool:
         return False
 
 
-def _probe_flucoma() -> bool:
-    """Check whether the ``flucoma`` Python package is importable.
+def _flucoma_package_dirs() -> list[Path]:
+    """Return likely Max package locations for FluCoMa."""
+    home = Path.home()
+    if os.name == "nt":
+        docs = Path(os.environ.get("USERPROFILE", str(home))) / "Documents"
+    else:
+        docs = home / "Documents"
+    return [
+        docs / "Max 9" / "Packages" / "FluidCorpusManipulation",
+        docs / "Max 8" / "Packages" / "FluidCorpusManipulation",
+    ]
 
-    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.
+
+def _probe_flucoma_package() -> bool:
+    """Check whether the FluCoMa Max package exists on disk.
+
+    LivePilot's real-time FluCoMa support is Max-for-Live based. There is
+    no required Python package named ``flucoma``; probing importability
+    caused false ``flucoma_not_installed`` reports on healthy systems.
     """
     try:
-        return importlib.util.find_spec("flucoma") is not None
+        for package_dir in _flucoma_package_dirs():
+            if not package_dir.exists():
+                continue
+            if (package_dir / "package-info.json").exists():
+                return True
+            externals = package_dir / "externals"
+            if externals.exists() and any(externals.glob("fluid.*")):
+                return True
+            return True
+        return False
     except Exception as exc:  # noqa: BLE001
-        logger.debug("_probe_flucoma failed: %s", exc)
+        logger.debug("_probe_flucoma_package failed: %s", exc)
         return False
 
 
+def _probe_flucoma(spectral=None) -> dict:
+    """Probe the Max/bridge-backed FluCoMa runtime.
+
+    ``available`` means at least one FluCoMa stream has reached the
+    spectral cache. ``device_loaded`` means the external package appears
+    installed (or streams prove it is working from a frozen analyzer).
+    """
+    package_installed = _probe_flucoma_package()
+    bridge_connected = bool(
+        spectral is not None and getattr(spectral, "is_connected", False)
+    )
+
+    streams: dict[str, bool] = {}
+    if bridge_connected:
+        for key in _FLUCOMA_STREAM_KEYS:
+            try:
+                streams[key] = spectral.get(key) is not None
+            except Exception as exc:  # noqa: BLE001
+                logger.debug("_probe_flucoma stream %s failed: %s", key, exc)
+                streams[key] = False
+
+    active_streams = sum(1 for present in streams.values() if present)
+    available = active_streams > 0
+    device_loaded = package_installed or available
+
+    reasons: list[str] = []
+    if not device_loaded:
+        reasons.append("flucoma_not_installed")
+    if not bridge_connected:
+        reasons.append("flucoma_bridge_unavailable")
+    elif not available:
+        reasons.append("flucoma_no_streams")
+
+    return {
+        "available": available,
+        "device_loaded": device_loaded,
+        "bridge_connected": bridge_connected,
+        "active_streams": active_streams,
+        "streams": streams,
+        "reasons": reasons,
+    }
+
+
+def _normalize_flucoma_probe(raw) -> dict:
+    """Back-compat shim for tests/extensions that monkeypatch a bool probe."""
+    if isinstance(raw, bool):
+        return {
+            "available": raw,
+            "device_loaded": raw,
+            "reasons": [] if raw else ["flucoma_not_installed"],
+        }
+    if isinstance(raw, dict):
+        available = bool(raw.get("available", False))
+        return {
+            **raw,
+            "available": available,
+            "device_loaded": bool(raw.get("device_loaded", available)),
+            "reasons": list(raw.get("reasons", [])),
+        }
+    return {
+        "available": False,
+        "device_loaded": False,
+        "reasons": ["flucoma_probe_failed"],
+    }
+
+
+def _run_flucoma_probe(spectral=None) -> dict:
+    try:
+        return _normalize_flucoma_probe(_probe_flucoma(spectral))
+    except TypeError:
+        # Older tests monkeypatch _probe_flucoma as a no-arg callable.
+        return _normalize_flucoma_probe(_probe_flucoma())
+
+
+def _session_info(ableton) -> dict:
+    try:
+        info = ableton.send_command("get_session_info")
+        return info if isinstance(info, dict) else {}
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("_session_info probe failed: %s", exc)
+        return {}
+
+
+def _live_version_from_session(session_info: dict) -> str:
+    version = session_info.get("live_version")
+    return str(version) if version else "12.0.0"
+
+
+def _normalize_probe_surface(
+    raw: Any,
+    *,
+    default_reason: str,
+    default_mode: str = "manual_only",
+) -> dict:
+    if isinstance(raw, dict):
+        mode = str(raw.get("mode") or default_mode)
+        available = bool(raw.get("available", mode in {"readable", "routable", "callable"}))
+        reasons = list(raw.get("reasons") or [])
+        if not available and not reasons:
+            reasons.append(default_reason)
+        return {
+            "mode": mode,
+            "available": available,
+            "reasons": reasons,
+            "observed": dict(raw.get("observed") or {}),
+        }
+    return {
+        "mode": default_mode,
+        "available": False,
+        "reasons": [default_reason],
+        "observed": {},
+    }
+
+
+def _probe_link_audio_surface(ableton, session_info: Optional[dict] = None) -> dict:
+    """Read-only Link Audio surface probe.
+
+    Current Live 12.4 builds expose Link Audio as product UX, but no stable
+    Remote Script/M4L routing contract has been proven. This helper looks for
+    explicit evidence if future Remote Scripts surface it; otherwise it reports
+    manual_only with a reason instead of claiming support from version alone.
+    """
+    info = session_info or _session_info(ableton)
+    observed = {
+        "peers_visible": bool(info.get("link_audio_peers") or info.get("link_peers")),
+        "inputs_visible": bool(info.get("link_audio_inputs") or info.get("audio_inputs")),
+        "routing_visible": bool(info.get("link_audio_routing")),
+    }
+    if observed["peers_visible"] and observed["inputs_visible"] and observed["routing_visible"]:
+        return {
+            "mode": "routable",
+            "available": True,
+            "reasons": [],
+            "observed": observed,
+        }
+    if observed["peers_visible"] or observed["inputs_visible"]:
+        return {
+            "mode": "readable",
+            "available": True,
+            "reasons": [],
+            "observed": observed,
+        }
+    return {
+        "mode": "manual_only",
+        "available": False,
+        "reasons": ["link_audio_not_exposed"],
+        "observed": observed,
+    }
+
+
+def _probe_stem_workflow_surface(ableton, session_info: Optional[dict] = None) -> dict:
+    """Read-only selected-time stem workflow probe.
+
+    This intentionally does not invoke stem separation. It only reports
+    callable evidence if a future Remote Script/M4L surface advertises a
+    stable command path.
+    """
+    info = session_info or _session_info(ableton)
+    callable_paths = list(info.get("stem_callable_paths") or [])
+    if callable_paths:
+        return {
+            "mode": "callable",
+            "available": True,
+            "reasons": [],
+            "observed": {"callable_paths": callable_paths},
+        }
+    return {
+        "mode": "manual_only",
+        "available": False,
+        "reasons": ["stem_command_not_observable"],
+        "observed": {"callable_paths": []},
+    }
+
+
+def _probe_live_12_4_domain(
+    *,
+    ableton,
+    session_info: dict,
+    feature_available: bool,
+    surface_probe,
+    default_reason: str,
+) -> dict:
+    live_version = _live_version_from_session(session_info)
+    if not feature_available:
+        return {
+            "ok": True,
+            "live_version": live_version,
+            "mode": "unavailable",
+            "available": False,
+            "reasons": ["live_version_below_12_4"],
+            "observed": {},
+        }
+    try:
+        surface = _normalize_probe_surface(
+            surface_probe(ableton, session_info=session_info),
+            default_reason=default_reason,
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.debug("Live 12.4 surface probe failed: %s", exc)
+        surface = {
+            "mode": "manual_only",
+            "available": False,
+            "reasons": [f"probe_failed: {type(exc).__name__}"],
+            "observed": {},
+        }
+    return {
+        "ok": True,
+        "live_version": live_version,
+        **surface,
+    }
+
+
+def _probe_link_audio_domain(ableton, session_info: dict) -> dict:
+    from .live_version import LiveVersionCapabilities
+
+    caps = LiveVersionCapabilities.from_session_info(session_info)
+    return _probe_live_12_4_domain(
+        ableton=ableton,
+        session_info=session_info,
+        feature_available=caps.has_link_audio,
+        surface_probe=_probe_link_audio_surface,
+        default_reason="link_audio_not_exposed",
+    )
+
+
+def _probe_stem_workflow_domain(ableton, session_info: dict) -> dict:
+    from .live_version import LiveVersionCapabilities
+
+    caps = LiveVersionCapabilities.from_session_info(session_info)
+    return _probe_live_12_4_domain(
+        ableton=ableton,
+        session_info=session_info,
+        feature_available=caps.has_stem_time_selection,
+        surface_probe=_probe_stem_workflow_surface,
+        default_reason="stem_command_not_observable",
+    )
+
+
+@mcp.tool()
+def probe_link_audio(ctx: Context) -> dict:
+    """Read-only probe for Live 12.4 Link Audio MCP controllability."""
+    ableton = ctx.lifespan_context["ableton"]
+    session_info = _session_info(ableton)
+    return _probe_link_audio_domain(ableton, session_info)
+
+
+@mcp.tool()
+def probe_stem_workflow(ctx: Context) -> dict:
+    """Read-only probe for Live 12.4 selected-time stem workflow support."""
+    ableton = ctx.lifespan_context["ableton"]
+    session_info = _session_info(ableton)
+    return _probe_stem_workflow_domain(ableton, session_info)
+
+
 @mcp.tool()
 def get_capability_state(ctx: Context) -> dict:
     """Probe the runtime and return a capability state snapshot.
@@ -77,13 +361,8 @@ def get_capability_state(ctx: Context) -> dict:
     spectral = ctx.lifespan_context.get("spectral")
 
     # ── Probe session ───────────────────────────────────────────────
-    session_ok = False
-    try:
-        result = ableton.send_command("get_session_info")
-        session_ok = isinstance(result, dict) and "error" not in result
-    except Exception as exc:
-        logger.debug("get_capability_state failed: %s", exc)
-        session_ok = False
+    session_info = _session_info(ableton)
+    session_ok = bool(session_info) and "error" not in session_info
 
     # ── Probe analyzer (M4L bridge) ─────────────────────────────────
     analyzer_ok = False
@@ -109,8 +388,12 @@ def get_capability_state(ctx: Context) -> dict:
     # 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()
+    # ── FluCoMa — Max package + live bridge streams ─────────────────
+    flucoma_probe = _run_flucoma_probe(spectral)
+
+    # ── Live 12.4 probe-first surfaces ──────────────────────────────
+    link_probe = _probe_link_audio_domain(ableton, session_info)
+    stem_probe = _probe_stem_workflow_domain(ableton, session_info)
 
     state = build_capability_state(
         session_ok=session_ok,
@@ -118,7 +401,13 @@ def get_capability_state(ctx: Context) -> dict:
         analyzer_fresh=analyzer_fresh,
         memory_ok=memory_ok,
         web_ok=web_ok,
-        flucoma_ok=flucoma_ok,
+        flucoma_ok=flucoma_probe["available"],
+        flucoma_device_loaded=flucoma_probe["device_loaded"],
+        flucoma_reasons=flucoma_probe["reasons"],
+        link_audio_mode=link_probe["mode"],
+        link_audio_reasons=link_probe["reasons"],
+        stem_workflow_mode=stem_probe["mode"],
+        stem_workflow_reasons=stem_probe["reasons"],
     )
 
     return state.to_dict()
@@ -134,6 +423,7 @@ def get_session_kernel(
     creativity_profile: str = "",
     sacred_elements: Optional[list] = None,
     synth_hints: Optional[dict] = None,
+    operation_profile: str = "studio_deep",
 ) -> dict:
     """Build the unified turn snapshot for V2 orchestration.
 
@@ -159,6 +449,9 @@ def get_session_kernel(
       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.
+      operation_profile: safety/intent posture for this turn. Known values:
+        safe_live, studio_deep, arrangement_build, sound_design_deep,
+        release_audit.
 
     Returns: SessionKernel dict with kernel_id, session topology, capabilities,
     memory context, routing hints, and (if provided) creative controls.
@@ -183,7 +476,9 @@ def get_session_kernel(
     # does, and propagate through. Without this the kernel's capability view
     # lies to orchestration planners.
     web_ok = _probe_web()
-    flucoma_ok = _probe_flucoma()
+    flucoma_probe = _run_flucoma_probe(spectral)
+    link_probe = _probe_link_audio_domain(ableton, session_info if isinstance(session_info, dict) else {})
+    stem_probe = _probe_stem_workflow_domain(ableton, session_info if isinstance(session_info, dict) else {})
 
     # v1.17.4: probe memory the same way too. Previously memory_ok=True was
     # hardcoded — if the store raised, the kernel still reported memory
@@ -201,7 +496,13 @@ def get_session_kernel(
         analyzer_fresh=analyzer_fresh,
         memory_ok=memory_ok,
         web_ok=web_ok,
-        flucoma_ok=flucoma_ok,
+        flucoma_ok=flucoma_probe["available"],
+        flucoma_device_loaded=flucoma_probe["device_loaded"],
+        flucoma_reasons=flucoma_probe["reasons"],
+        link_audio_mode=link_probe["mode"],
+        link_audio_reasons=link_probe["reasons"],
+        stem_workflow_mode=stem_probe["mode"],
+        stem_workflow_reasons=stem_probe["reasons"],
     )
 
     # Optional subcomponents — degrade gracefully, but reach into the SAME
@@ -286,6 +587,7 @@ def get_session_kernel(
         anti_preferences=anti_prefs,
         freshness=freshness,
         creativity_profile=creativity_profile,
+        operation_profile=operation_profile,
         sacred_elements=sacred_elements,
         synth_hints=synth_hints,
     )

package/mcp_server/sound_design/tools.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 from fastmcp import Context
 
 from ..server import mcp
+from ..evaluation.feature_extractors import extract_character_profile
+from ..tools._snapshot_normalizer import normalize_sonic_snapshot
 from .models import (
     LayerStrategy,
     PatchBlock,
@@ -189,9 +191,36 @@ def _fetch_sound_design_data(ctx: Context, track_index: int) -> dict:
     # Get devices from track_info response (already included by Remote Script)
     devices: list[dict] = track_info.get("devices", [])
 
+    sonic = None
+    try:
+        spectral = ctx.lifespan_context.get("spectral")
+        if spectral and spectral.is_connected:
+            sonic = {}
+            spec_data = spectral.get("spectrum")
+            if spec_data:
+                sonic["bands"] = spec_data["value"]
+            rms_snap = spectral.get("rms")
+            if rms_snap:
+                sonic["rms"] = rms_snap["value"]
+            peak_snap = spectral.get("peak")
+            if peak_snap:
+                sonic["peak"] = peak_snap["value"]
+            key_snap = spectral.get("key")
+            if key_snap:
+                sonic["detected_key"] = key_snap["value"]
+            for key in ("spectral_shape", "mel_bands", "chroma", "onset", "novelty", "loudness"):
+                snap = spectral.get(key)
+                if snap:
+                    sonic[key] = snap["value"]
+            if not sonic:
+                sonic = None
+    except Exception:
+        sonic = None
+
     return {
         "track_info": track_info,
         "devices": devices,
+        "sonic_snapshot": normalize_sonic_snapshot(sonic, source="sound_design"),
     }
 
 
@@ -262,9 +291,11 @@ def analyze_sound_design(ctx: Context, track_index: int) -> dict:
         issues, data["track_info"].get("name", "")
     )
     moves = plan_sound_design_moves(issues, state)
+    sonic_character = extract_character_profile(data.get("sonic_snapshot") or {})
 
     return {
         "state": state.to_dict(),
+        "sonic_character": sonic_character,
         "issues": [i.to_dict() for i in issues],
         "suggested_moves": [m.to_dict() for m in moves],
         "issue_count": len(issues),
@@ -295,6 +326,7 @@ def get_sound_design_issues(ctx: Context, track_index: int) -> dict:
     )
 
     return {
+        "sonic_character": extract_character_profile(data.get("sonic_snapshot") or {}),
         "issues": [i.to_dict() for i in issues],
         "issue_count": len(issues),
     }
@@ -330,6 +362,7 @@ def plan_sound_design_move(ctx: Context, track_index: int) -> dict:
     moves = plan_sound_design_moves(issues, state)
 
     result: dict = {
+        "sonic_character": extract_character_profile(data.get("sonic_snapshot") or {}),
         "moves": [m.to_dict() for m in moves],
         "move_count": len(moves),
         "issue_count": len(issues),

package/mcp_server/tools/_agent_os_engine/evaluation.py

@@ -11,6 +11,10 @@ import re
 from dataclasses import asdict, dataclass, field
 from typing import Any, Optional
 
+from ...evaluation.feature_extractors import (
+    extract_dimension_value as _shared_extract_dimension_value,
+)
+from .._snapshot_normalizer import normalize_sonic_snapshot
 from .models import QUALITY_DIMENSIONS, GoalVector, WorldModel, _clamp
 from .taste import compute_taste_fit
 
@@ -29,50 +33,10 @@ def _extract_dimension_value(
     """
     if not sonic:
         return None
-    # Accept both "spectrum" and "bands" keys — get_master_spectrum returns
-    # {"bands": {...}} while the evaluator historically expected {"spectrum": {...}}.
-    # Finding 2 fix: tolerate either shape so raw analyzer output works.
-    bands = sonic.get("spectrum") or sonic.get("bands")
-    if not bands:
-        return None
-    rms = sonic.get("rms")
-    peak = sonic.get("peak")
-
-    if dimension == "brightness":
-        high = bands.get("high", 0)
-        presence = bands.get("presence", 0)
-        return _clamp((high + presence) / 2.0)
-    elif dimension == "warmth":
-        return _clamp(bands.get("low_mid", 0))
-    elif dimension == "weight":
-        sub = bands.get("sub", 0)
-        low = bands.get("low", 0)
-        return _clamp((sub + low) / 2.0)
-    elif dimension == "clarity":
-        low_mid = bands.get("low_mid", 0)
-        return _clamp(1.0 - low_mid)
-    elif dimension == "density":
-        # Spectral flatness: geometric mean / arithmetic mean of band values.
-        # Higher = more evenly distributed energy (noise-like).
-        # Lower = more tonal (energy concentrated in few bands).
-        vals = [max(v, 1e-10) for v in bands.values() if isinstance(v, (int, float))]
-        if not vals:
-            return None
-        geo_mean = math.exp(sum(math.log(v) for v in vals) / len(vals))
-        arith_mean = sum(vals) / len(vals)
-        return _clamp(geo_mean / max(arith_mean, 1e-10))
-    elif dimension == "energy":
-        return _clamp(rms) if rms is not None else None
-    elif dimension == "punch":
-        if rms and peak and rms > 0:
-            crest_db = 20.0 * math.log10(max(peak / rms, 1.0))
-            # Normalize: 0 dB = 0.0, 20 dB = 1.0
-            return _clamp(crest_db / 20.0)
-        return None
-    else:
-        # Unmeasurable in Phase 1 (width, depth, motion, contrast,
-        # groove, tension, novelty, polish, emotion, cohesion)
+    normalized = normalize_sonic_snapshot(sonic, source="agent_os")
+    if normalized is None:
         return None
+    return _shared_extract_dimension_value(normalized, dimension)
 
 def compute_evaluation_score(
     goal: GoalVector,
@@ -203,4 +167,3 @@ def compute_evaluation_score(
         # I5: hint for the agent to track consecutive undos
         "consecutive_undo_hint": not keep_change,
     }
-

package/mcp_server/tools/_agent_os_engine/models.py

@@ -33,6 +33,8 @@ MEASURABLE_PROXIES: dict[str, str] = {
     "density": "spectral flatness (geometric/arithmetic mean ratio)",
     "energy": "RMS level",
     "punch": "crest factor in dB (20*log10(peak/rms))",
+    "motion": "spectral novelty + onset strength",
+    "novelty": "FluCoMa novelty score",
 }
 
 VALID_MODES = frozenset({"observe", "improve", "explore", "finish", "diagnose"})
@@ -129,4 +131,3 @@ class TechniqueCard:
             "verification": self.verification,
             "evidence": self.evidence,
         }
-

package/mcp_server/tools/_conductor.py

@@ -70,7 +70,7 @@ class ConductorPlan:
 _ROUTING_PATTERNS: list[tuple[str, str, str, str, list[str]]] = [
     # Mix requests
     (r"clean|mud|muddy|low.?mid|eq|equaliz", "mix_engine", "mix", "analyze_mix", ["plan_mix_move", "evaluate_mix_move"]),
-    (r"punch|punchy|transient|dynamics|compress", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
+    (r"dynamics|compress|crest|over.?compress|flat.?dynamics", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
     (r"wide|wider|width|stereo|narrow|mono.?compat", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
     (r"glue|cohes|bus.?comp|mix.?bus", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
     (r"balance|level|volume.?balanc|gain.?stag", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
@@ -87,6 +87,7 @@ _ROUTING_PATTERNS: list[tuple[str, str, str, str, list[str]]] = [
 
     # Sound design requests
     (r"synth|patch|oscillat|timbre|timbral|wavetable|operator", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
+    (r"punch|punchy|hit.?harder|snap|attack|transient", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
     (r"haunted|lush|aggressive|warm.?pad|fat.?bass|bright.?lead", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
     (r"modulation|lfo|movement|evolv|texture", "sound_design", "sound_design", "get_patch_model", ["analyze_sound_design"]),
     (r"layer|sub.?layer|transient.?layer|body", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
@@ -254,7 +255,7 @@ def classify_request(request: str) -> ConductorPlan:
 
     # Determine capability requirements
     caps = ["session_access"]
-    if any(r.engine == "mix_engine" for r in routes):
+    if any(r.engine in ("mix_engine", "sound_design") for r in routes):
         caps.append("analyzer")
     if any(r.engine in ("reference_engine",) for r in routes):
         caps.append("offline_perception")
@@ -267,6 +268,8 @@ def classify_request(request: str) -> ConductorPlan:
         notes.append("Multi-engine task — start with get_session_kernel for shared state")
     if any(r.engine == "mix_engine" for r in routes):
         notes.append("Mix engine works best with analyzer data — check get_capability_state")
+    if any(r.engine == "sound_design" for r in routes):
+        notes.append("Sound design should use analyzer character before level or pan changes")
 
     # V2: Search semantic moves for matching intents
     semantic_moves = _find_matching_semantic_moves(lower)

package/mcp_server/tools/_evaluation_contracts.py

@@ -22,7 +22,7 @@ from typing import Optional
 # must report confidence=0.0 for that dimension.
 MEASURABLE_DIMENSIONS: frozenset[str] = frozenset({
     "brightness", "warmth", "weight", "clarity",
-    "density", "energy", "punch",
+    "density", "energy", "punch", "motion", "novelty",
 })
 
 # All valid quality dimensions (measurable + unmeasurable).