livepilot 1.10.5 → 1.10.7

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,
+    )
+

package/mcp_server/tools/_composition_engine/__init__.py

@@ -0,0 +1,67 @@
+"""Composition engine — structural + musical intelligence for arrangement.
+
+This package replaces the former single-file `_composition_engine.py`.
+The public surface is unchanged — callers import the same names:
+
+    from mcp_server.tools._composition_engine import (
+        SectionType, RoleType, GestureIntent,
+        build_section_graph_from_scenes, detect_phrases,
+        run_form_critic, plan_gesture, ...,
+    )
+
+Internal organization:
+    models.py     — Enums and dataclasses (shared types)
+    sections.py   — Section graph, phrase grid, role inference
+    critics.py    — Form / identity / phrase / transition / emotional / cross-section
+    gestures.py   — Gesture planner and template library
+    harmony.py    — Harmony field construction
+    analysis.py   — Composition evaluation, outcomes, taste model, constants
+"""
+from __future__ import annotations
+
+from .models import (
+    SectionType, RoleType, GestureIntent,
+    SectionNode, PhraseUnit, RoleNode, CompositionIssue,
+    GesturePlan, CompositionAnalysis, HarmonyField,
+)
+from .sections import (
+    build_section_graph_from_scenes,
+    build_section_graph_from_arrangement,
+    detect_phrases,
+    infer_role_for_track,
+    build_role_graph,
+)
+from .critics import (
+    run_form_critic,
+    run_section_identity_critic,
+    run_phrase_critic,
+    run_transition_critic,
+    run_emotional_arc_critic,
+    run_cross_section_critic,
+)
+from .gestures import (
+    GESTURE_TEMPLATES,
+    plan_gesture,
+    resolve_gesture_template,
+)
+from .harmony import build_harmony_field, harmonic_score
+from .analysis import (
+    COMPOSITION_DIMENSIONS,
+    analyze_section_outcomes,
+    evaluate_composition_move,
+    build_composition_taste_model,
+)
+
+__all__ = [
+    "SectionType", "RoleType", "GestureIntent",
+    "SectionNode", "PhraseUnit", "RoleNode", "CompositionIssue",
+    "GesturePlan", "CompositionAnalysis", "HarmonyField",
+    "build_section_graph_from_scenes", "build_section_graph_from_arrangement",
+    "detect_phrases", "infer_role_for_track", "build_role_graph",
+    "run_form_critic", "run_section_identity_critic", "run_phrase_critic",
+    "run_transition_critic", "run_emotional_arc_critic", "run_cross_section_critic",
+    "GESTURE_TEMPLATES", "plan_gesture", "resolve_gesture_template",
+    "build_harmony_field", "harmonic_score",
+    "COMPOSITION_DIMENSIONS", "analyze_section_outcomes",
+    "evaluate_composition_move", "build_composition_taste_model",
+]

package/mcp_server/tools/_composition_engine/analysis.py

@@ -0,0 +1,174 @@
+"""Part of the _composition_engine package — extracted from the single-file engine.
+
+Pure-computation core, no external deps. Callers should import from the package
+facade (e.g. `from mcp_server.tools._composition_engine import X`), which
+re-exports everything from these sub-modules.
+"""
+from __future__ import annotations
+
+import math
+import re
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any, Optional
+
+from .models import SectionNode, CompositionIssue, CompositionAnalysis
+
+
+# ── Section Outcome Analysis (Round 2) ────────────────────────────────
+def analyze_section_outcomes(
+    outcomes: list[dict],
+) -> dict:
+    """Analyze composition outcomes grouped by section type.
+
+    outcomes: list of composition_outcome payloads
+    Returns: {section_type: {move_name: {avg_score, count, keep_rate}}}
+    """
+    by_section: dict[str, list[dict]] = {}
+
+    for o in outcomes:
+        section_type = o.get("section_type", "unknown")
+        by_section.setdefault(section_type, []).append(o)
+
+    result = {}
+    for stype, section_outcomes in by_section.items():
+        move_stats: dict[str, dict] = {}
+        for o in section_outcomes:
+            move = o.get("move_name", "unknown")
+            stats = move_stats.setdefault(move, {"scores": [], "kept": 0, "total": 0})
+            stats["scores"].append(o.get("score", 0))
+            stats["total"] += 1
+            if o.get("kept", False):
+                stats["kept"] += 1
+
+        result[stype] = {
+            move: {
+                "avg_score": round(sum(s["scores"]) / len(s["scores"]), 3) if s["scores"] else 0,
+                "count": s["total"],
+                "keep_rate": round(s["kept"] / s["total"], 3) if s["total"] > 0 else 0,
+            }
+            for move, s in move_stats.items()
+        }
+
+    return {
+        "section_types": list(result.keys()),
+        "outcomes_by_section": result,
+        "total_outcomes": sum(len(v) for v in by_section.values()),
+    }
+
+
+# ── Composition Evaluation ────────────────────────────────────────────
+COMPOSITION_DIMENSIONS = frozenset({
+    "section_clarity", "phrase_completion", "narrative_pacing",
+    "transition_strength", "orchestration_clarity", "tension_release",
+})
+
+def evaluate_composition_move(
+    before_issues: list[CompositionIssue],
+    after_issues: list[CompositionIssue],
+    target_dimensions: dict[str, float],
+    protect: dict[str, float],
+) -> dict:
+    """Evaluate whether a composition move improved the arrangement.
+
+    Compares issue counts and severities before and after.
+    Returns: {score, keep_change, issue_delta, notes}
+    """
+    notes: list[str] = []
+
+    # Count issues by type before and after
+    before_count = len(before_issues)
+    after_count = len(after_issues)
+    issue_delta = before_count - after_count
+
+    # Severity-weighted improvement
+    before_severity = sum(i.severity for i in before_issues)
+    after_severity = sum(i.severity for i in after_issues)
+    severity_improvement = before_severity - after_severity
+
+    # Score: positive improvement = good
+    if before_count > 0:
+        improvement_ratio = severity_improvement / max(before_severity, 0.01)
+    else:
+        improvement_ratio = 0.0 if after_count == 0 else -0.5
+
+    # Normalize to 0-1 score
+    score = max(0.0, min(1.0, 0.5 + improvement_ratio * 0.5))
+
+    # Keep/undo decision
+    keep_change = True
+
+    if severity_improvement < 0:
+        keep_change = False
+        notes.append(f"WORSE: total severity increased by {-severity_improvement:.2f}")
+
+    if after_count > before_count + 1:
+        keep_change = False
+        notes.append(f"NEW ISSUES: {after_count - before_count} new issues introduced")
+
+    if score < 0.40:
+        keep_change = False
+        notes.append(f"SCORE: {score:.3f} below 0.40 threshold")
+
+    if keep_change and severity_improvement > 0:
+        notes.append(f"IMPROVED: resolved {issue_delta} issue(s), severity reduced by {severity_improvement:.2f}")
+
+    return {
+        "score": round(score, 4),
+        "keep_change": keep_change,
+        "issue_delta": issue_delta,
+        "before_issue_count": before_count,
+        "after_issue_count": after_count,
+        "severity_improvement": round(severity_improvement, 4),
+        "notes": notes,
+        "consecutive_undo_hint": not keep_change,
+    }
+
+
+# ── Composition Taste Model (Round 4) ───────────────────────────────
+def build_composition_taste_model(
+    section_outcomes: list[dict],
+) -> dict:
+    """Build per-section-type preferences from composition outcome history.
+
+    Aggregates section outcomes to learn: what density, foreground count,
+    and move types does this user prefer for each section type?
+
+    Returns: {section_type: {preferred_density, preferred_foreground_count,
+              top_moves, sample_size}}
+    """
+    if not section_outcomes:
+        return {"section_types": {}, "sample_size": 0}
+
+    by_type: dict[str, list[dict]] = {}
+    for o in section_outcomes:
+        stype = o.get("section_type", "unknown")
+        by_type.setdefault(stype, []).append(o)
+
+    preferences: dict[str, dict] = {}
+    for stype, outcomes in by_type.items():
+        kept = [o for o in outcomes if o.get("kept", False)]
+        densities = [o.get("density", 0.5) for o in kept if "density" in o]
+        fg_counts = [o.get("foreground_count", 1) for o in kept if "foreground_count" in o]
+
+        # Tally move types
+        move_counts: dict[str, int] = {}
+        for o in kept:
+            move = o.get("move_name", "unknown")
+            move_counts[move] = move_counts.get(move, 0) + 1
+
+        top_moves = sorted(move_counts.items(), key=lambda x: -x[1])[:3]
+
+        preferences[stype] = {
+            "preferred_density": round(sum(densities) / len(densities), 2) if densities else 0.5,
+            "preferred_foreground_count": round(sum(fg_counts) / len(fg_counts), 1) if fg_counts else 1.0,
+            "top_moves": [{"move": m, "count": c} for m, c in top_moves],
+            "keep_rate": round(len(kept) / len(outcomes), 3) if outcomes else 0,
+            "sample_size": len(outcomes),
+        }
+
+    return {
+        "section_types": preferences,
+        "sample_size": sum(len(v) for v in by_type.values()),
+    }
+