livepilot 1.10.4 → 1.10.6

package/mcp_server/tools/_agent_os_engine/models.py

@@ -0,0 +1,132 @@
+"""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
+
+
+# ── Shared utility ────────────────────────────────────────────────────
+def _clamp(value: float, lo: float = 0.0, hi: float = 1.0) -> float:
+    """Clamp value to [lo, hi] range. Shared across evaluation + taste."""
+    return max(lo, min(hi, value))
+
+
+# ── Quality Dimensions ────────────────────────────────────────────────
+QUALITY_DIMENSIONS = frozenset({
+    "energy", "punch", "weight", "density", "brightness", "warmth",
+    "width", "depth", "motion", "contrast", "clarity", "cohesion",
+    "groove", "tension", "novelty", "polish", "emotion",
+})
+
+MEASURABLE_PROXIES: dict[str, str] = {
+    "brightness": "high + presence bands (averaged)",
+    "warmth": "low_mid band energy",
+    "weight": "sub + low bands (averaged)",
+    "clarity": "inverse of low_mid congestion",
+    "density": "spectral flatness (geometric/arithmetic mean ratio)",
+    "energy": "RMS level",
+    "punch": "crest factor in dB (20*log10(peak/rms))",
+}
+
+VALID_MODES = frozenset({"observe", "improve", "explore", "finish", "diagnose"})
+
+VALID_RESEARCH_MODES = frozenset({"none", "targeted", "deep"})
+
+
+# ── GoalVector ────────────────────────────────────────────────────────
+@dataclass
+class GoalVector:
+    """Compiled user intent as a machine-usable goal.
+
+    targets: dimension → weight (0-1). Weights should approximately sum to 1.0.
+    protect: dimension → minimum acceptable value (0-1). If a dimension drops
+             below this value after a move, the move is undone.
+    """
+    request_text: str
+    targets: dict[str, float] = field(default_factory=dict)
+    protect: dict[str, float] = field(default_factory=dict)
+    mode: str = "improve"
+    aggression: float = 0.5
+    research_mode: str = "none"
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+_ROLE_PATTERNS: list[tuple[str, str]] = [
+    (r"kick|bd|bass\s*drum", "kick"),
+    (r"snare|sd|snr", "snare"),
+    (r"clap|cp|hand\s*clap", "clap"),
+    (r"h(?:i)?[\s\-]?hat|hh|hat", "hihat"),
+    (r"perc|percussion|conga|bongo|shaker|tamb", "percussion"),
+    (r"sub\s*bass|sub", "sub_bass"),
+    (r"bass|low", "bass"),
+    (r"pad|atmosphere|atmo|ambient|drone", "pad"),
+    (r"lead|melody|mel|synth\s*lead", "lead"),
+    (r"chord|keys|piano|organ|rhodes", "chords"),
+    (r"vocal|vox|voice", "vocal"),
+    (r"fx|sfx|riser|sweep|noise|texture|tape", "texture"),
+    (r"string", "strings"),
+    (r"brass", "brass"),
+    (r"resamp|bounce|bus|group|master", "utility"),
+]
+
+@dataclass
+class WorldModel:
+    """Session state snapshot for critic analysis."""
+    topology: dict = field(default_factory=dict)
+    sonic: Optional[dict] = None
+    technical: dict = field(default_factory=dict)
+    track_roles: dict = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+# ── Critics ───────────────────────────────────────────────────────────
+@dataclass
+class Issue:
+    """A diagnosed problem or opportunity."""
+    type: str
+    critic: str  # "sonic" or "technical"
+    severity: float  # 0.0-1.0
+    confidence: float  # 0.0-1.0
+    affected_dimensions: list[str] = field(default_factory=list)
+    evidence: list[str] = field(default_factory=list)
+    recommended_actions: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+# ── Technique Cards (Round 2) ─────────────────────────────────────────
+@dataclass
+class TechniqueCard:
+    """A structured, reusable production recipe — not just text."""
+    problem: str
+    context: list[str] = field(default_factory=list)  # genre/style tags
+    devices: list[str] = field(default_factory=list)  # what to load
+    method: str = ""  # step-by-step instructions
+    verification: list[str] = field(default_factory=list)  # what to check after
+    evidence: dict = field(default_factory=dict)  # {sources, in_session_tested}
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    def to_memory_payload(self) -> dict:
+        """Convert to a payload suitable for memory_learn(type='technique_card')."""
+        return {
+            "problem": self.problem,
+            "context": self.context,
+            "devices": self.devices,
+            "method": self.method,
+            "verification": self.verification,
+            "evidence": self.evidence,
+        }
+

package/mcp_server/tools/_agent_os_engine/taste.py

@@ -0,0 +1,192 @@
+"""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, _clamp
+
+
+# ── Outcome Memory Analysis (Round 1) ────────────────────────────────
+def analyze_outcome_history(outcomes: list[dict]) -> dict:
+    """Analyze accumulated outcome memories to identify user taste patterns.
+
+    outcomes: list of outcome technique payloads from memory_list(type="outcome")
+    Returns taste analysis: keep rate, dimension success, inferred preferences.
+    """
+    if not outcomes:
+        return {
+            "total_outcomes": 0,
+            "keep_rate": 0.0,
+            "dimension_success": {},
+            "common_kept_moves": [],
+            "common_undone_moves": [],
+            "taste_vector": {},
+            "notes": ["No outcome history — use the evaluation loop to build taste data"],
+        }
+
+    total = len(outcomes)
+    kept = [o for o in outcomes if o.get("kept", False)]
+    undone = [o for o in outcomes if not o.get("kept", False)]
+    keep_rate = len(kept) / total
+
+    # Dimension success: average improvement per dimension when kept
+    dimension_success: dict[str, list[float]] = {}
+    for o in kept:
+        for dim, change in o.get("dimension_changes", {}).items():
+            delta = change.get("delta", 0) if isinstance(change, dict) else 0
+            dimension_success.setdefault(dim, []).append(delta)
+
+    avg_dimension_success = {
+        dim: round(sum(vals) / len(vals), 4)
+        for dim, vals in dimension_success.items()
+        if vals
+    }
+
+    # Common move types
+    kept_moves = {}
+    undone_moves = {}
+    for o in kept:
+        move_name = o.get("move", {}).get("name", "unknown") if isinstance(o.get("move"), dict) else "unknown"
+        kept_moves[move_name] = kept_moves.get(move_name, 0) + 1
+    for o in undone:
+        move_name = o.get("move", {}).get("name", "unknown") if isinstance(o.get("move"), dict) else "unknown"
+        undone_moves[move_name] = undone_moves.get(move_name, 0) + 1
+
+    common_kept = sorted(kept_moves.items(), key=lambda x: -x[1])[:5]
+    common_undone = sorted(undone_moves.items(), key=lambda x: -x[1])[:5]
+
+    # Taste vector: which dimensions does this user care about?
+    # Weight by how often each dimension appears in kept outcomes
+    taste_vector: dict[str, float] = {}
+    for o in kept:
+        gv = o.get("goal_vector", {})
+        targets = gv.get("targets", {}) if isinstance(gv, dict) else {}
+        for dim, weight in targets.items():
+            taste_vector[dim] = taste_vector.get(dim, 0) + weight
+
+    # Normalize
+    taste_total = sum(taste_vector.values())
+    if taste_total > 0:
+        taste_vector = {k: round(v / taste_total, 3) for k, v in taste_vector.items()}
+
+    notes = []
+    if keep_rate < 0.3:
+        notes.append(f"Low keep rate ({keep_rate:.0%}) — agent may be too aggressive")
+    if keep_rate > 0.8:
+        notes.append(f"High keep rate ({keep_rate:.0%}) — agent is well-calibrated or too conservative")
+
+    return {
+        "total_outcomes": total,
+        "kept": len(kept),
+        "undone": len(undone),
+        "keep_rate": round(keep_rate, 3),
+        "dimension_success": avg_dimension_success,
+        "common_kept_moves": [{"move": m, "count": c} for m, c in common_kept],
+        "common_undone_moves": [{"move": m, "count": c} for m, c in common_undone],
+        "taste_vector": taste_vector,
+        "notes": notes,
+    }
+
+
+# ── Taste Model (Round 4) ────────────────────────────────────────────
+def compute_taste_fit(
+    goal: GoalVector,
+    outcome_history: Optional[list[dict]] = None,
+) -> float:
+    """Compute how well a goal aligns with the user's accumulated taste preferences.
+
+    Analyzes outcome history to build a taste vector (which dimensions matter
+    most to this user), then scores the current goal's alignment.
+
+    Returns 0.0-1.0 where:
+    - 0.0 = no data or goal doesn't match taste
+    - 1.0 = goal perfectly aligns with user's demonstrated preferences
+    """
+    if not outcome_history:
+        return 0.0
+
+    # Build taste vector from kept outcomes
+    taste_vector: dict[str, float] = {}
+    total_kept = 0
+
+    for o in outcome_history:
+        if not o.get("kept", False):
+            continue
+        total_kept += 1
+        gv = o.get("goal_vector", {})
+        targets = gv.get("targets", {}) if isinstance(gv, dict) else {}
+        for dim, weight in targets.items():
+            taste_vector[dim] = taste_vector.get(dim, 0) + weight
+
+    if not taste_vector or total_kept == 0:
+        return 0.0
+
+    # Normalize taste vector
+    taste_total = sum(taste_vector.values())
+    if taste_total > 0:
+        taste_vector = {k: v / taste_total for k, v in taste_vector.items()}
+
+    # Score: how much does the current goal overlap with taste preferences?
+    # Dot product of normalized goal weights and taste weights
+    goal_targets = goal.targets
+    if not goal_targets:
+        return 0.0
+
+    goal_total = sum(goal_targets.values())
+    if goal_total <= 0:
+        return 0.0
+
+    overlap = 0.0
+    for dim, weight in goal_targets.items():
+        normalized_weight = weight / goal_total
+        taste_weight = taste_vector.get(dim, 0)
+        overlap += normalized_weight * taste_weight
+
+    # Scale: overlap is typically small (product of two normalized distributions)
+    # Amplify so that moderate overlap gives a meaningful score
+    return _clamp(overlap * 4.0)
+
+def get_taste_profile(outcome_history: list[dict]) -> dict:
+    """Build a full taste profile from outcome history.
+
+    Returns: {taste_vector, preferred_dimensions, avoided_dimensions,
+              keep_rate, sample_size}
+    """
+    analysis = analyze_outcome_history(outcome_history)
+    taste_vector = analysis.get("taste_vector", {})
+
+    # Identify preferred and avoided dimensions
+    preferred = sorted(taste_vector.items(), key=lambda x: -x[1])[:5]
+    avoided_dims: dict[str, float] = {}
+    for o in outcome_history:
+        if o.get("kept", False):
+            continue  # Only look at undone moves
+        gv = o.get("goal_vector", {})
+        targets = gv.get("targets", {}) if isinstance(gv, dict) else {}
+        for dim, weight in targets.items():
+            avoided_dims[dim] = avoided_dims.get(dim, 0) + weight
+
+    if avoided_dims:
+        avoid_total = sum(avoided_dims.values())
+        if avoid_total > 0:
+            avoided_dims = {k: v / avoid_total for k, v in avoided_dims.items()}
+
+    avoided = sorted(avoided_dims.items(), key=lambda x: -x[1])[:5]
+
+    return {
+        "taste_vector": taste_vector,
+        "preferred_dimensions": [{"dim": d, "weight": round(w, 3)} for d, w in preferred],
+        "avoided_dimensions": [{"dim": d, "weight": round(w, 3)} for d, w in avoided],
+        "keep_rate": analysis.get("keep_rate", 0),
+        "sample_size": analysis.get("total_outcomes", 0),
+        "notes": analysis.get("notes", []),
+    }
+

package/mcp_server/tools/_agent_os_engine/techniques.py

@@ -0,0 +1,161 @@
+"""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 TechniqueCard
+
+def build_technique_card_from_outcome(outcome: dict) -> Optional[TechniqueCard]:
+    """Extract a technique card from a successful outcome.
+
+    Only produces a card if the outcome was kept and had meaningful improvement.
+    """
+    if not outcome.get("kept", False):
+        return None
+    if outcome.get("score", 0) < 0.6:
+        return None
+
+    gv = outcome.get("goal_vector", {})
+    move = outcome.get("move", {})
+    dim_changes = outcome.get("dimension_changes", {})
+
+    # Build problem description from goal
+    targets = gv.get("targets", {})
+    if not targets:
+        return None
+
+    top_dim = max(targets.items(), key=lambda x: x[1])[0] if targets else "general"
+    problem = f"Improve {top_dim} in production"
+
+    # Build method from move
+    method = move.get("name", "unknown technique")
+    if isinstance(move.get("actions"), list):
+        method = " → ".join(move["actions"])
+
+    # Build verification from dimension changes
+    verification = []
+    for dim, change in dim_changes.items():
+        if isinstance(change, dict) and change.get("delta", 0) > 0:
+            verification.append(f"{dim} should improve (was +{change['delta']:.3f})")
+
+    return TechniqueCard(
+        problem=problem,
+        context=list(gv.get("tags", [])) if isinstance(gv.get("tags"), list) else [],
+        devices=move.get("devices", []) if isinstance(move.get("devices"), list) else [],
+        method=method,
+        verification=verification,
+        evidence={"score": outcome.get("score", 0), "in_session_tested": True},
+    )
+
+
+# ── Background Technique Mining (Round 3) ───────────────────────────
+def should_mine_technique(
+    outcome: dict,
+    existing_techniques: Optional[list[dict]] = None,
+) -> bool:
+    """Determine if an outcome is novel enough to auto-create a technique card.
+
+    Returns True if:
+    - Score > 0.7 (high quality)
+    - At least one dimension improved by > 0.15
+    - No similar technique already exists in memory
+    """
+    if not outcome.get("kept", False):
+        return False
+    if outcome.get("score", 0) < 0.7:
+        return False
+
+    # Check for meaningful dimension improvement
+    dim_changes = outcome.get("dimension_changes", {})
+    has_significant_improvement = False
+    for dim, change in dim_changes.items():
+        delta = change.get("delta", 0) if isinstance(change, dict) else 0
+        if delta > 0.15:
+            has_significant_improvement = True
+            break
+
+    if not has_significant_improvement:
+        return False
+
+    # Check for novelty — don't create duplicate techniques
+    if existing_techniques:
+        move = outcome.get("move", {})
+        move_name = move.get("name", "") if isinstance(move, dict) else ""
+        if move_name:
+            for tech in existing_techniques:
+                payload = tech.get("payload", {})
+                existing_method = payload.get("method", "")
+                if move_name.lower() in existing_method.lower():
+                    return False  # Similar technique already exists
+
+    return True
+
+def mine_technique_from_outcome(outcome: dict) -> Optional[TechniqueCard]:
+    """Extract a technique card from a high-quality outcome.
+
+    This is the "background mining" — when the agent detects a novel
+    approach that worked well, it auto-creates a technique card for future use.
+    """
+    if not outcome.get("kept", False):
+        return None
+
+    gv = outcome.get("goal_vector", {})
+    move = outcome.get("move", {})
+    dim_changes = outcome.get("dimension_changes", {})
+    score = outcome.get("score", 0)
+
+    # Build problem description
+    targets = gv.get("targets", {})
+    if targets:
+        top_dims = sorted(targets.items(), key=lambda x: -x[1])[:2]
+        problem = f"Improve {' and '.join(d for d, _ in top_dims)}"
+    else:
+        problem = "General production improvement"
+
+    # Build method
+    move_name = move.get("name", "unknown") if isinstance(move, dict) else str(move)
+    actions = move.get("actions", []) if isinstance(move, dict) else []
+    if isinstance(actions, list) and actions:
+        method = f"{move_name}: {' → '.join(str(a) for a in actions)}"
+    else:
+        method = move_name
+
+    # Build verification from what actually improved
+    verification = []
+    for dim, change in dim_changes.items():
+        if isinstance(change, dict) and change.get("delta", 0) > 0.05:
+            verification.append(
+                f"{dim} should improve (observed +{change['delta']:.3f})"
+            )
+
+    # Devices used
+    devices = move.get("devices", []) if isinstance(move, dict) else []
+    if not isinstance(devices, list):
+        devices = []
+
+    return TechniqueCard(
+        problem=problem,
+        context=list(gv.get("tags", [])) if isinstance(gv.get("tags"), list) else [],
+        devices=devices,
+        method=method,
+        verification=verification,
+        evidence={
+            "score": score,
+            "in_session_tested": True,
+            "auto_mined": True,
+            "dimension_improvements": {
+                dim: change.get("delta", 0)
+                for dim, change in dim_changes.items()
+                if isinstance(change, dict) and change.get("delta", 0) > 0
+            },
+        },
+    )
+

package/mcp_server/tools/_agent_os_engine/world_model.py

@@ -0,0 +1,170 @@
+"""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, MEASURABLE_PROXIES, VALID_MODES, VALID_RESEARCH_MODES, _ROLE_PATTERNS, GoalVector, WorldModel
+
+def validate_goal_vector(
+    request_text: str,
+    targets: dict[str, float],
+    protect: dict[str, float],
+    mode: str,
+    aggression: float,
+    research_mode: str,
+) -> GoalVector:
+    """Validate and construct a GoalVector. Raises ValueError on invalid input."""
+    if not request_text or not request_text.strip():
+        raise ValueError("request_text cannot be empty")
+
+    # Validate dimensions
+    for dim in targets:
+        if dim not in QUALITY_DIMENSIONS:
+            raise ValueError(
+                f"Unknown target dimension '{dim}'. "
+                f"Valid: {sorted(QUALITY_DIMENSIONS)}"
+            )
+    for dim in protect:
+        if dim not in QUALITY_DIMENSIONS:
+            raise ValueError(
+                f"Unknown protect dimension '{dim}'. "
+                f"Valid: {sorted(QUALITY_DIMENSIONS)}"
+            )
+
+    # Validate weights are non-negative
+    for dim, w in targets.items():
+        if w < 0.0:
+            raise ValueError(f"Target weight for '{dim}' must be >= 0.0, got {w}")
+    for dim, w in protect.items():
+        if not 0.0 <= w <= 1.0:
+            raise ValueError(f"Protect threshold for '{dim}' must be 0.0-1.0, got {w}")
+
+    if mode not in VALID_MODES:
+        raise ValueError(f"mode must be one of {sorted(VALID_MODES)}, got '{mode}'")
+    if research_mode not in VALID_RESEARCH_MODES:
+        raise ValueError(
+            f"research_mode must be one of {sorted(VALID_RESEARCH_MODES)}, "
+            f"got '{research_mode}'"
+        )
+    if not 0.0 <= aggression <= 1.0:
+        raise ValueError(f"aggression must be 0.0-1.0, got {aggression}")
+
+    # Normalize target weights to sum to ~1.0 if they don't already
+    total = sum(targets.values())
+    if targets and total > 0:
+        if abs(total - 1.0) > 0.01:
+            targets = {k: v / total for k, v in targets.items()}
+
+    return GoalVector(
+        request_text=request_text.strip(),
+        targets=targets,
+        protect=protect,
+        mode=mode,
+        aggression=aggression,
+        research_mode=research_mode,
+    )
+
+def infer_track_role(track_name: str) -> str:
+    """Infer a track's musical role from its name. Returns 'unknown' if no match."""
+    name_lower = track_name.lower().strip()
+    for pattern, role in _ROLE_PATTERNS:
+        if re.search(pattern, name_lower):
+            return role
+    return "unknown"
+
+def build_world_model_from_data(
+    session_info: dict,
+    spectrum: Optional[dict] = None,
+    rms: Optional[dict] = None,
+    detected_key: Optional[dict] = None,
+    flucoma_status: Optional[dict] = None,
+    track_infos: Optional[list[dict]] = None,
+) -> WorldModel:
+    """Assemble a WorldModel from raw tool outputs.
+
+    All parameters are optional — the model degrades gracefully when
+    analyzer data is unavailable.
+    """
+    # Topology
+    tracks = session_info.get("tracks", [])
+    topology = {
+        "tempo": session_info.get("tempo"),
+        "time_signature": f"{session_info.get('signature_numerator', 4)}/{session_info.get('signature_denominator', 4)}",
+        "track_count": session_info.get("track_count", 0),
+        "return_count": session_info.get("return_track_count", 0),
+        "scene_count": session_info.get("scene_count", 0),
+        "is_playing": session_info.get("is_playing", False),
+        "tracks": [
+            {
+                "index": t.get("index"),
+                "name": t.get("name", ""),
+                "has_midi": t.get("has_midi_input", False),
+                "has_audio": t.get("has_audio_input", False),
+                "mute": t.get("mute", False),
+                "solo": t.get("solo", False),
+                "arm": t.get("arm", False),
+            }
+            for t in tracks
+        ],
+    }
+
+    # Track roles
+    track_roles = {}
+    for t in tracks:
+        idx = t.get("index", 0)
+        name = t.get("name", "")
+        track_roles[idx] = infer_track_role(name)
+
+    # Sonic state (None if analyzer unavailable)
+    sonic = None
+    if spectrum and spectrum.get("bands"):
+        sonic = {
+            "spectrum": spectrum.get("bands", {}),
+            "rms": rms.get("rms") if rms else None,
+            "peak": rms.get("peak") if rms else None,
+            "key": detected_key.get("key") if detected_key else None,
+            "scale": detected_key.get("scale") if detected_key else None,
+            "key_confidence": detected_key.get("confidence") if detected_key else None,
+        }
+
+    # Technical state
+    analyzer_available = spectrum is not None and bool(spectrum.get("bands"))
+    flucoma_available = (
+        flucoma_status is not None
+        and flucoma_status.get("flucoma_available", False)
+    )
+
+    # Check plugin health from track_infos if provided
+    unhealthy_devices = []
+    if track_infos:
+        for ti in track_infos:
+            for dev in ti.get("devices", []):
+                flags = dev.get("health_flags", [])
+                if "opaque_or_failed_plugin" in flags:
+                    unhealthy_devices.append({
+                        "track": ti.get("index"),
+                        "device": dev.get("name"),
+                        "flag": "opaque_or_failed_plugin",
+                    })
+
+    technical = {
+        "analyzer_available": analyzer_available,
+        "flucoma_available": flucoma_available,
+        "unhealthy_devices": unhealthy_devices,
+    }
+
+    return WorldModel(
+        topology=topology,
+        sonic=sonic,
+        technical=technical,
+        track_roles=track_roles,
+    )
+