livepilot 1.10.4 → 1.10.6

package/mcp_server/session_continuity/tracker.py

@@ -7,6 +7,7 @@ Separates taste (cross-session) from identity (in-song) ranking.
 from __future__ import annotations
 
 import hashlib
+import logging
 import time
 from typing import Optional
 
@@ -17,6 +18,8 @@ from .models import (
     TurnResolution,
 )
 
+logger = logging.getLogger(__name__)
+
 
 # ── In-memory state ───────────────────────────────────────────────
 
@@ -129,9 +132,8 @@ def record_turn_resolution(
     if _project_store is not None:
         try:
             _project_store.save_turn(turn.to_dict())
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("record_turn_resolution failed: %s", exc)
     return turn
 
 
@@ -158,9 +160,8 @@ def open_thread(description: str, domain: str = "", priority: float = 0.5) -> Cr
     if _project_store is not None:
         try:
             _project_store.save_thread(thread.to_dict())
-        except Exception:
-            pass
-
+        except Exception as exc:
+            logger.debug("open_thread failed: %s", exc)
     return thread
 
 
@@ -173,8 +174,8 @@ def resolve_thread(thread_id: str) -> Optional[CreativeThread]:
         if _project_store is not None:
             try:
                 _project_store.save_thread(thread.to_dict())
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("resolve_thread failed: %s", exc)
     return thread
 
 

package/mcp_server/song_brain/tools.py

@@ -12,7 +12,9 @@ from fastmcp import Context
 from ..server import mcp
 from . import builder
 from .models import SongBrain
+import logging
 
+logger = logging.getLogger(__name__)
 
 # Module-level fallback for consumers without ctx.
 # Prefer ctx.lifespan_context["current_brain"] when ctx is available.
@@ -67,7 +69,8 @@ def _fetch_session_data(ctx: Context) -> dict:
 
     try:
         data["session_info"] = ableton.send_command("get_session_info", {})
-    except Exception:
+    except Exception as exc:
+        logger.debug("_fetch_session_data failed: %s", exc)
         data["session_info"] = {"tempo": 120.0, "track_count": 0}
 
     try:
@@ -78,22 +81,23 @@ def _fetch_session_data(ctx: Context) -> dict:
                 zip(matrix.get("scenes", []), matrix.get("matrix", []))
             )
         ]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_session_data failed: %s", exc)
 
     try:
         info = data["session_info"]
         tracks_list = info.get("tracks", [])
         data["tracks"] = tracks_list if isinstance(tracks_list, list) else []
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_session_data failed: %s", exc)
 
     # Motif data — via shared motif service (pure-Python, not TCP)
     try:
         from ..services.motif_service import get_motif_data, fetch_notes_from_ableton
         notes_by_track = fetch_notes_from_ableton(ableton, data.get("tracks", []))
         data["motif_data"] = get_motif_data(notes_by_track)
-    except Exception:
+    except Exception as exc:
+        logger.debug("_fetch_session_data failed: %s", exc)
         pass  # Motif graph requires notes in clips; empty is valid
 
     # Composition analysis — from musical intelligence detectors (pure computation)
@@ -106,8 +110,8 @@ def _fetch_session_data(ctx: Context) -> dict:
             "sections": [p.to_dict() for p in purposes],
             "emotional_arc": arc.to_dict(),
         }
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_session_data failed: %s", exc)
 
     # Role graph — from semantic move resolvers (pure computation, no I/O)
     try:
@@ -118,8 +122,8 @@ def _fetch_session_data(ctx: Context) -> dict:
             role = infer_role(name)
             roles[name] = {"index": track.get("index", 0), "role": role}
         data["role_graph"] = roles
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_session_data failed: %s", exc)
 
     # Recent moves — from session-scoped action ledger
     try:
@@ -128,8 +132,8 @@ def _fetch_session_data(ctx: Context) -> dict:
         if isinstance(ledger, SessionLedger):
             recent = ledger.get_recent_moves(limit=10)
             data["recent_moves"] = [e.to_dict() for e in recent]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_fetch_session_data failed: %s", exc)
 
     return data
 
@@ -152,6 +156,7 @@ def build_song_brain(ctx: Context) -> dict:
 
     # Capability reporting — what data was actually available
     from ..runtime.capability import build_capability
+
     cap = build_capability(
         required=["session_info", "scenes", "tracks", "motif_data", "composition_analysis", "role_graph"],
         available={

package/mcp_server/splice_client/client.py

@@ -190,12 +190,25 @@ class SpliceGRPCClient:
     ) -> Optional[str]:
         """Download a sample by file_hash. Returns local path when complete.
 
-        Costs 1 credit. Checks credit floor before downloading.
-        Returns None on failure.
+        Costs 1 credit. Enforces CREDIT_HARD_FLOOR defensively — refuses the
+        download (returns None) if completing it would leave the user at or
+        below the floor, regardless of what the caller requested. Callers
+        should still gate on `can_afford` upstream for UX, but this guard
+        closes the hole if a future caller forgets.
         """
         if not self.connected:
             return None
 
+        # Defensive floor guard — do not rely on callers alone.
+        can, remaining = await self.can_afford(1, budget=1)
+        if not can:
+            logger.warning(
+                "Splice download blocked by credit floor guard "
+                "(remaining=%s, floor=%s, file_hash=%s)",
+                remaining, CREDIT_HARD_FLOOR, file_hash,
+            )
+            return None
+
         pb2 = self._pb2
         try:
             # Trigger download
@@ -221,8 +234,8 @@ class SpliceGRPCClient:
                 )
                 if response.Sample.LocalPath:
                     return response.Sample.LocalPath
-            except Exception:
-                pass
+            except Exception as exc:
+                logger.debug("_wait_for_download failed: %s", exc)
             await asyncio.sleep(0.5)
         logger.warning(f"Download timed out for {file_hash}")
         return None
@@ -304,9 +317,9 @@ class SpliceGRPCClient:
         try:
             await self.stub.SyncSounds(pb2.SyncSoundsRequest())
             return True
-        except Exception:
+        except Exception as exc:
+            logger.debug("sync_sounds failed: %s", exc)
             return False
-
     # ── Connection Helpers ──────────────────────────────────────────
 
     def _read_port(self) -> Optional[int]:

package/mcp_server/stuckness_detector/tools.py

@@ -11,6 +11,9 @@ from fastmcp import Context
 
 from ..server import mcp
 from . import detector
+import logging
+
+logger = logging.getLogger(__name__)
 
 
 def _get_ableton(ctx: Context):
@@ -30,8 +33,8 @@ def _get_action_history(ctx: Context) -> list[dict]:
         if isinstance(ledger, SessionLedger):
             recent = ledger.get_recent_moves(limit=20)
             return [e.to_dict() for e in recent]
-    except Exception:
-        pass
+    except Exception as exc:
+        logger.debug("_get_action_history failed: %s", exc)
     return []
 
 
@@ -45,9 +48,8 @@ def _get_session_and_brain(ctx: Context) -> tuple[dict, dict, int]:
     try:
         session_info = ableton.send_command("get_session_info", {})
         section_count = session_info.get("scene_count", 0)
-    except Exception:
-        pass
-
+    except Exception as exc:
+        logger.debug("_get_session_and_brain failed: %s", exc)
     try:
         from ..song_brain.tools import _current_brain
         if _current_brain is not None:
@@ -165,6 +167,7 @@ def start_rescue_workflow(
 
     # Build a rescue suggestion for this specific type
     from .models import StucknessReport
+
     report = StucknessReport(
         confidence=0.6,
         level="stuck",

package/mcp_server/tools/_agent_os_engine/__init__.py

@@ -0,0 +1,52 @@
+"""Agent OS engine — goal compilation, world model, evaluation.
+
+This package replaces the former single-file `_agent_os_engine.py`.
+Public surface unchanged — callers import the same names.
+
+Internal organization:
+    models.py       — Dataclasses + module-level constants
+    world_model.py  — Goal validation, role inference, world-model build
+    critics.py      — Sonic + technical critics
+    evaluation.py   — Scoring, dimension extraction, clamp helpers
+    techniques.py   — TechniqueCard mining + building
+    taste.py        — Outcome analysis, taste fit, taste profile
+"""
+from __future__ import annotations
+
+from .models import (
+    QUALITY_DIMENSIONS, MEASURABLE_PROXIES,
+    VALID_MODES, VALID_RESEARCH_MODES,
+    GoalVector, WorldModel, Issue, TechniqueCard,
+)
+from .world_model import (
+    validate_goal_vector,
+    infer_track_role,
+    build_world_model_from_data,
+)
+from .critics import run_sonic_critic, run_technical_critic
+from .evaluation import compute_evaluation_score, _extract_dimension_value
+from .techniques import (
+    build_technique_card_from_outcome,
+    should_mine_technique,
+    mine_technique_from_outcome,
+)
+from .taste import (
+    analyze_outcome_history,
+    compute_taste_fit,
+    get_taste_profile,
+)
+
+__all__ = [
+    "QUALITY_DIMENSIONS", "MEASURABLE_PROXIES",
+    "VALID_MODES", "VALID_RESEARCH_MODES",
+    "GoalVector", "WorldModel", "Issue", "TechniqueCard",
+    "validate_goal_vector", "infer_track_role", "build_world_model_from_data",
+    "run_sonic_critic", "run_technical_critic",
+    "compute_evaluation_score",
+    "build_technique_card_from_outcome",
+    "should_mine_technique",
+    "mine_technique_from_outcome",
+    "analyze_outcome_history",
+    "compute_taste_fit",
+    "get_taste_profile",
+]

package/mcp_server/tools/_agent_os_engine/critics.py

@@ -0,0 +1,134 @@
+"""Part of the _agent_os_engine package — extracted from the single-file engine.
+
+Pure-computation core. Callers should import from the package facade
+(`from mcp_server.tools._agent_os_engine import X`), which re-exports from
+these sub-modules.
+"""
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any, Optional
+
+from .models import Issue, GoalVector, WorldModel, MEASURABLE_PROXIES
+
+def run_sonic_critic(
+    sonic: Optional[dict],
+    goal: GoalVector,
+    track_roles: dict,
+) -> list[Issue]:
+    """Run sonic heuristics against spectrum data. Returns issues that overlap
+    with the goal's target dimensions."""
+    if sonic is None:
+        return [Issue(
+            type="analyzer_unavailable",
+            critic="sonic",
+            severity=0.3,
+            confidence=1.0,
+            affected_dimensions=list(MEASURABLE_PROXIES.keys()),
+            evidence=["M4L Analyzer not connected or no audio playing"],
+            recommended_actions=["Load LivePilot_Analyzer on master", "Start playback"],
+        )]
+
+    issues = []
+    bands = sonic.get("spectrum", {})
+    rms = sonic.get("rms")
+    peak = sonic.get("peak")
+    target_dims = set(goal.targets.keys())
+
+    # 1. Mud detection: low_mid congestion
+    low_mid = bands.get("low_mid", 0)
+    if low_mid > 0.7 and {"clarity", "weight", "warmth"} & target_dims:
+        issues.append(Issue(
+            type="low_mid_congestion",
+            critic="sonic",
+            severity=min(1.0, (low_mid - 0.7) * 3.3),
+            confidence=0.85,
+            affected_dimensions=["clarity", "weight"],
+            evidence=[f"low_mid band energy: {low_mid:.2f} (threshold: 0.7)"],
+            recommended_actions=["EQ cut 200-500Hz on muddiest track", "HPF on non-bass elements"],
+        ))
+
+    # 2. Weak sub
+    sub = bands.get("sub", 0)
+    has_bass = any(r in ("kick", "bass", "sub_bass") for r in track_roles.values())
+    if sub < 0.15 and has_bass and {"weight", "energy", "punch"} & target_dims:
+        issues.append(Issue(
+            type="weak_foundation",
+            critic="sonic",
+            severity=0.6,
+            confidence=0.75,
+            affected_dimensions=["weight", "energy"],
+            evidence=[f"sub band energy: {sub:.2f} with bass tracks present"],
+            recommended_actions=["Boost sub on kick/bass", "Check HPF not too aggressive"],
+        ))
+
+    # 3. Harsh top
+    high = bands.get("high", 0)
+    presence = bands.get("presence", 0)
+    if (high + presence) > 0.8 and {"brightness", "clarity", "warmth"} & target_dims:
+        issues.append(Issue(
+            type="harsh_highs",
+            critic="sonic",
+            severity=min(1.0, ((high + presence) - 0.8) * 2.5),
+            confidence=0.80,
+            affected_dimensions=["brightness", "clarity"],
+            evidence=[f"high+presence: {high + presence:.2f} (threshold: 0.8)"],
+            recommended_actions=["Reduce high shelf on brightest element", "Add subtle LP filter"],
+        ))
+
+    # 4. Low headroom
+    if rms is not None and rms > 0.9 and {"energy", "punch", "clarity"} & target_dims:
+        issues.append(Issue(
+            type="headroom_risk",
+            critic="sonic",
+            severity=min(1.0, (rms - 0.9) * 10),
+            confidence=0.90,
+            affected_dimensions=["energy", "clarity", "punch"],
+            evidence=[f"RMS: {rms:.3f} (threshold: 0.9)"],
+            recommended_actions=["Reduce master volume", "Lower loudest track", "Add limiter"],
+        ))
+
+    # 5. Flat dynamics (C1 fix: correct dB formula)
+    if rms is not None and peak is not None and rms > 0 and peak > 0:
+        crest_db = 20.0 * math.log10(peak / max(rms, 0.001))
+        if crest_db < 3.0 and {"punch", "energy", "contrast"} & target_dims:
+            issues.append(Issue(
+                type="dynamics_flat",
+                critic="sonic",
+                severity=0.5,
+                confidence=0.70,
+                affected_dimensions=["punch", "contrast"],
+                evidence=[f"crest factor: {crest_db:.1f} dB (threshold: 3 dB)"],
+                recommended_actions=["Reduce compression", "Add transient shaper", "Reduce limiter"],
+            ))
+
+    return issues
+
+def run_technical_critic(technical: dict) -> list[Issue]:
+    """Check technical health of the session."""
+    issues = []
+
+    if not technical.get("analyzer_available", False):
+        issues.append(Issue(
+            type="analyzer_offline",
+            critic="technical",
+            severity=0.4,
+            confidence=1.0,
+            evidence=["LivePilot Analyzer not receiving data"],
+            recommended_actions=["Load LivePilot_Analyzer.amxd on master track"],
+        ))
+
+    for dev in technical.get("unhealthy_devices", []):
+        issues.append(Issue(
+            type="unhealthy_plugin",
+            critic="technical",
+            severity=0.7,
+            confidence=0.95,
+            evidence=[f"Track {dev['track']}: {dev['device']} — {dev['flag']}"],
+            recommended_actions=["Delete and replace with native Ableton device"],
+        ))
+
+    return issues
+

package/mcp_server/tools/_agent_os_engine/evaluation.py

@@ -0,0 +1,206 @@
+"""Part of the _agent_os_engine package — extracted from the single-file engine.
+
+Pure-computation core. Callers should import from the package facade
+(`from mcp_server.tools._agent_os_engine import X`), which re-exports from
+these sub-modules.
+"""
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import asdict, dataclass, field
+from typing import Any, Optional
+
+from .models import QUALITY_DIMENSIONS, GoalVector, WorldModel, _clamp
+from .taste import compute_taste_fit
+
+
+# ── Evaluation Engine ─────────────────────────────────────────────────
+# _clamp lives in .models — shared with taste.py to avoid circular imports.
+
+def _extract_dimension_value(
+    sonic: dict,
+    dimension: str,
+) -> Optional[float]:
+    """Map a quality dimension to a measurable value from sonic data.
+
+    Returns None for unmeasurable dimensions (confidence=0.0 in Phase 1).
+    All returned values are clamped to 0.0-1.0 for consistent scoring.
+    """
+    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)
+        return None
+
+def compute_evaluation_score(
+    goal: GoalVector,
+    before_sonic: dict,
+    after_sonic: dict,
+    outcome_history: Optional[list[dict]] = None,
+) -> dict:
+    """Compute whether a move improved the mix toward the goal.
+
+    Returns:
+        {
+            "score": float (0-1),
+            "keep_change": bool,
+            "goal_progress": float (-1 to 1),
+            "collateral_damage": float (0-1),
+            "measurable_delta": float (-1 to 1),
+            "notes": list[str],
+            "dimension_changes": dict,
+            "consecutive_undo_hint": bool,
+        }
+    """
+    notes: list[str] = []
+    dimension_changes: dict[str, dict] = {}
+
+    # Compute per-dimension deltas
+    total_goal_progress = 0.0
+    measurable_count = 0
+
+    for dim, weight in goal.targets.items():
+        before_val = _extract_dimension_value(before_sonic, dim)
+        after_val = _extract_dimension_value(after_sonic, dim)
+
+        if before_val is not None and after_val is not None:
+            delta = after_val - before_val
+            dimension_changes[dim] = {
+                "before": round(before_val, 4),
+                "after": round(after_val, 4),
+                "delta": round(delta, 4),
+            }
+            total_goal_progress += delta * weight
+            measurable_count += 1
+        else:
+            notes.append(f"{dim}: not measurable in Phase 1 (confidence=0.0)")
+
+    # Check protected dimensions (C3 fix: use the actual threshold)
+    collateral_damage = 0.0
+    protection_violated = False
+
+    for dim, threshold in goal.protect.items():
+        before_val = _extract_dimension_value(before_sonic, dim)
+        after_val = _extract_dimension_value(after_sonic, dim)
+
+        if before_val is not None and after_val is not None:
+            drop = before_val - after_val
+            if drop > 0:
+                collateral_damage = max(collateral_damage, drop)
+            # Violation: value dropped below the user's threshold
+            if after_val < threshold:
+                protection_violated = True
+                notes.append(
+                    f"PROTECTED dimension '{dim}' at {after_val:.3f}, "
+                    f"below threshold {threshold:.3f}"
+                )
+            # Also flag large drops even if still above threshold
+            elif drop > 0.15:
+                protection_violated = True
+                notes.append(
+                    f"PROTECTED dimension '{dim}' dropped by {drop:.3f} "
+                    f"(absolute drop > 0.15)"
+                )
+
+    # Measurable delta (average improvement across measured dimensions)
+    measurable_delta = total_goal_progress / max(measurable_count, 1)
+
+    # Taste fit: how well does this move align with user preferences?
+    taste_fit = compute_taste_fit(goal, outcome_history) if outcome_history else 0.0
+
+    # Compute composite score (spec section 12.2)
+    goal_fit = _clamp(0.5 + total_goal_progress)
+    measurable_component = _clamp(0.5 + measurable_delta)
+    preservation = _clamp(1.0 - collateral_damage * 5)
+    confidence = measurable_count / max(len(goal.targets), 1)
+
+    score = (
+        0.30 * goal_fit
+        + 0.25 * measurable_component
+        + 0.15 * preservation
+        + 0.10 * taste_fit
+        + 0.10 * confidence
+        + 0.10 * 1.0   # reversibility: 1.0 for undo-able moves
+    )
+
+    # Hard rules
+    keep_change = True
+
+    if measurable_count > 0 and measurable_delta <= 0:
+        keep_change = False
+        notes.append("HARD RULE: measurable delta <= 0 — no measurable improvement")
+
+    if protection_violated:
+        keep_change = False
+        notes.append("HARD RULE: protected dimension violated")
+
+    if score < 0.40:
+        keep_change = False
+        notes.append(f"HARD RULE: total score {score:.3f} < 0.40 threshold")
+
+    if measurable_count == 0 and not protection_violated:
+        # All TARGET dimensions unmeasurable AND no protection violations —
+        # defer keep/undo to the agent's musical judgment.
+        # IMPORTANT: protection violations still force undo even when
+        # targets are unmeasurable (Finding 1 fix).
+        keep_change = True
+        notes.append(
+            "No measurable target dimensions — deferring keep/undo to agent musical judgment"
+        )
+
+    return {
+        "score": round(score, 4),
+        "keep_change": keep_change,
+        "goal_progress": round(total_goal_progress, 4),
+        "collateral_damage": round(collateral_damage, 4),
+        "measurable_delta": round(measurable_delta, 4),
+        "measurable_dimensions": measurable_count,
+        "total_dimensions": len(goal.targets),
+        "dimension_changes": dimension_changes,
+        "notes": notes,
+        # I5: hint for the agent to track consecutive undos
+        "consecutive_undo_hint": not keep_change,
+    }
+