livepilot 1.9.21 → 1.9.23

package/mcp_server/semantic_moves/compiler.py

@@ -0,0 +1,116 @@
+"""Semantic move compiler — resolves intents to concrete tool call sequences.
+
+The compiler takes a SemanticMove + SessionKernel and produces a CompiledPlan:
+a list of concrete, parameterized tool calls ready for execution.
+
+Each move family registers a compiler function. The generic compile() dispatcher
+routes to the right family compiler based on the move's family field.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Optional
+
+from .models import SemanticMove
+
+
+# ── Compiled plan types ──────────────────────────────────────────────────────
+
+@dataclass
+class CompiledStep:
+    """A single executable tool call with resolved parameters."""
+    tool: str                    # MCP tool name, e.g. "set_track_volume"
+    params: dict                 # Concrete params, e.g. {"track_index": 0, "volume": 0.72}
+    description: str             # Human-readable, e.g. "Push Drums from 0.65 → 0.72"
+    verify_after: bool = True    # Whether to check meters after this step
+
+    def to_dict(self) -> dict:
+        return {
+            "tool": self.tool,
+            "params": self.params,
+            "description": self.description,
+            "verify_after": self.verify_after,
+        }
+
+
+@dataclass
+class CompiledPlan:
+    """The output of compilation — ready for execution or presentation."""
+    move_id: str
+    intent: str
+    steps: list[CompiledStep] = field(default_factory=list)
+    before_reads: list[dict] = field(default_factory=list)
+    after_reads: list[dict] = field(default_factory=list)
+    risk_level: str = "low"
+    summary: str = ""
+    requires_approval: bool = True
+    warnings: list[str] = field(default_factory=list)
+
+    @property
+    def step_count(self) -> int:
+        return len(self.steps)
+
+    @property
+    def executable(self) -> bool:
+        """A plan is executable if it has at least one step."""
+        return len(self.steps) > 0
+
+    def to_dict(self) -> dict:
+        return {
+            "move_id": self.move_id,
+            "intent": self.intent,
+            "steps": [s.to_dict() for s in self.steps],
+            "step_count": self.step_count,
+            "before_reads": self.before_reads,
+            "after_reads": self.after_reads,
+            "risk_level": self.risk_level,
+            "summary": self.summary,
+            "requires_approval": self.requires_approval,
+            "executable": self.executable,
+            "warnings": self.warnings,
+        }
+
+
+# ── Compiler registry ────────────────────────────────────────────────────────
+
+CompilerFn = Callable[[SemanticMove, dict], CompiledPlan]
+_COMPILERS: dict[str, CompilerFn] = {}
+
+
+def register_compiler(move_id: str, fn: CompilerFn) -> None:
+    """Register a compiler function for a specific move."""
+    _COMPILERS[move_id] = fn
+
+
+def register_family_compiler(family: str, fn: CompilerFn) -> None:
+    """Register a fallback compiler for an entire move family."""
+    _COMPILERS[f"__family__{family}"] = fn
+
+
+def compile(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile a semantic move against a session kernel.
+
+    Looks up the compiler by move_id first, then falls back to family compiler,
+    then returns a non-executable plan with a warning.
+    """
+    # Try move-specific compiler
+    fn = _COMPILERS.get(move.move_id)
+    if fn:
+        return fn(move, kernel)
+
+    # Try family fallback
+    fn = _COMPILERS.get(f"__family__{move.family}")
+    if fn:
+        return fn(move, kernel)
+
+    # No compiler found — return a descriptive but non-executable plan
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=[],
+        summary=f"No compiler registered for move '{move.move_id}'. "
+                f"The agent should interpret the intent and execute manually.",
+        requires_approval=True,
+        warnings=[f"No compiler for {move.move_id} — manual execution required"],
+    )

package/mcp_server/semantic_moves/mix_compilers.py

@@ -0,0 +1,291 @@
+"""Concrete compilers for mix-domain semantic moves.
+
+Each compiler function takes (move, kernel) and returns a CompiledPlan
+with fully parameterized tool calls. The compiler inspects the kernel's
+track topology and device chains to resolve targets.
+
+Pure functions — no I/O. All data comes from the kernel dict.
+"""
+
+from __future__ import annotations
+
+from .compiler import CompiledPlan, CompiledStep, register_compiler
+from .models import SemanticMove
+from . import resolvers
+
+
+def _compile_make_punchier(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'make_punchier': push drums, pull pads, tighten master bus."""
+    steps = []
+    warnings = []
+    descriptions = []
+
+    # Find drum track
+    drum_tracks = resolvers.find_tracks_by_role(kernel, ["drums", "percussion"])
+    if not drum_tracks:
+        # Fallback: look for "unknown" role tracks (often drums)
+        drum_tracks = resolvers.find_tracks_by_role(kernel, ["unknown"])
+    if not drum_tracks:
+        warnings.append("No drum track found — skipping drum push")
+
+    # Find pad/texture tracks
+    pad_tracks = resolvers.find_tracks_by_role(kernel, ["pad", "fx"])
+
+    # Step 1: Read current state
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Read current levels for all tracks",
+        verify_after=False,
+    ))
+
+    # Step 2: Push drum volume
+    for dt in drum_tracks[:1]:  # Only first drum track
+        idx = dt["index"]
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": idx, "volume": 0.75},
+            description=f"Push {dt['name']} (track {idx}) to 0.75 for transient punch",
+        ))
+        descriptions.append(f"Push {dt['name']} volume to 0.75")
+
+    # Step 3: Pull back pads
+    for pt in pad_tracks:
+        idx = pt["index"]
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": idx, "volume": 0.25},
+            description=f"Pull {pt['name']} (track {idx}) to 0.25 for contrast",
+        ))
+        descriptions.append(f"Pull {pt['name']} volume to 0.25")
+
+    # Step 4: Verify
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify all tracks still producing audio",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_track_meters", "params": {"include_stereo": True}}],
+        after_reads=[
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+            {"tool": "get_master_spectrum", "params": {}},
+        ],
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No changes compiled",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_tighten_low_end(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'tighten_low_end': reduce sub volume, boost bass harmonics."""
+    steps = []
+    warnings = []
+    descriptions = []
+
+    bass_tracks = resolvers.find_tracks_by_role(kernel, ["bass"])
+    if not bass_tracks:
+        warnings.append("No bass track found — cannot tighten low end")
+        return CompiledPlan(
+            move_id=move.move_id,
+            intent=move.intent,
+            summary="No bass track found",
+            warnings=warnings,
+        )
+
+    bass = bass_tracks[0]
+    idx = bass["index"]
+
+    # Step 1: Read spectrum
+    steps.append(CompiledStep(
+        tool="get_master_spectrum",
+        params={},
+        description="Read current spectral balance",
+        verify_after=False,
+    ))
+
+    # Step 2: Reduce bass volume slightly
+    steps.append(CompiledStep(
+        tool="set_track_volume",
+        params={"track_index": idx, "volume": 0.58},
+        description=f"Reduce {bass['name']} volume to 0.58 (tighten sub)",
+    ))
+    descriptions.append(f"Reduce {bass['name']} volume to 0.58")
+
+    # Step 3: Verify
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify bass still producing audio after reduction",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_master_spectrum", "params": {}}],
+        after_reads=[
+            {"tool": "get_master_spectrum", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="low",
+        summary="; ".join(descriptions),
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_widen_stereo(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'widen_stereo': pan harmonic elements wider, add depth."""
+    steps = []
+    warnings = []
+    descriptions = []
+
+    chord_tracks = resolvers.find_tracks_by_role(kernel, ["chords", "pad"])
+    lead_tracks = resolvers.find_tracks_by_role(kernel, ["lead"])
+    perc_tracks = resolvers.find_tracks_by_role(kernel, ["percussion"])
+
+    if not chord_tracks and not lead_tracks:
+        warnings.append("No harmonic or lead tracks found for stereo widening")
+
+    # Pan chords left
+    for ct in chord_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_pan",
+            params={"track_index": ct["index"], "pan": -0.35},
+            description=f"Pan {ct['name']} left (-35%) for width",
+        ))
+        descriptions.append(f"Pan {ct['name']} left 35%")
+
+    # Pan lead right
+    for lt in lead_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_pan",
+            params={"track_index": lt["index"], "pan": 0.30},
+            description=f"Pan {lt['name']} right (+30%) for width",
+        ))
+        descriptions.append(f"Pan {lt['name']} right 30%")
+
+    # Pan perc slightly
+    for pt in perc_tracks[:1]:
+        steps.append(CompiledStep(
+            tool="set_track_pan",
+            params={"track_index": pt["index"], "pan": 0.15},
+            description=f"Pan {pt['name']} slightly right (+15%)",
+        ))
+        descriptions.append(f"Pan {pt['name']} slightly right")
+
+    # Verify
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify stereo output on all panned tracks",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "analyze_mix", "params": {}}],
+        after_reads=[
+            {"tool": "analyze_mix", "params": {}},
+            {"tool": "get_track_meters", "params": {"include_stereo": True}},
+        ],
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No panning changes",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+        warnings=warnings,
+    )
+
+
+def _compile_darken_mix(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'darken_without_losing_width': reduce brightness, preserve stereo."""
+    steps = []
+    descriptions = []
+
+    # Find bright-sounding tracks (leads and chords)
+    bright_tracks = resolvers.find_tracks_by_role(kernel, ["lead", "chords", "percussion"])
+
+    for bt in bright_tracks[:2]:  # Max 2 tracks
+        # Reduce volume slightly to darken
+        steps.append(CompiledStep(
+            tool="set_track_volume",
+            params={"track_index": bt["index"], "volume": 0.40},
+            description=f"Pull {bt['name']} to 0.40 for darker tone",
+        ))
+        descriptions.append(f"Darken {bt['name']} to 0.40")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify all tracks still active after darkening",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[{"tool": "get_master_spectrum", "params": {}}],
+        after_reads=[{"tool": "get_master_spectrum", "params": {}}],
+        risk_level="low",
+        summary="; ".join(descriptions) if descriptions else "No changes",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+def _compile_reduce_repetition(move: SemanticMove, kernel: dict) -> CompiledPlan:
+    """Compile 'reduce_repetition_fatigue': add perlin automation for organic movement."""
+    steps = []
+    descriptions = []
+
+    # Find melodic tracks for filter drift
+    melodic = resolvers.find_tracks_by_role(kernel, ["chords", "lead", "pad"])
+
+    for mt in melodic[:2]:  # Max 2 tracks
+        steps.append(CompiledStep(
+            tool="apply_automation_shape",
+            params={
+                "track_index": mt["index"],
+                "clip_index": 0,
+                "parameter_type": "send",
+                "send_index": 0,
+                "curve_type": "perlin",
+                "center": 0.2,
+                "amplitude": 0.1,
+                "duration": 8,
+                "density": 16,
+            },
+            description=f"Add perlin reverb send drift on {mt['name']}",
+        ))
+        descriptions.append(f"Perlin reverb drift on {mt['name']}")
+
+    steps.append(CompiledStep(
+        tool="get_track_meters",
+        params={"include_stereo": True},
+        description="Verify tracks still active after automation",
+    ))
+
+    return CompiledPlan(
+        move_id=move.move_id,
+        intent=move.intent,
+        steps=steps,
+        before_reads=[],
+        after_reads=[{"tool": "get_track_meters", "params": {"include_stereo": True}}],
+        risk_level="medium",
+        summary="; ".join(descriptions) if descriptions else "No melodic tracks found",
+        requires_approval=(kernel.get("mode", "improve") != "explore"),
+    )
+
+
+# ── Register all compilers ──────────────────────────────────────────────────
+
+register_compiler("make_punchier", _compile_make_punchier)
+register_compiler("tighten_low_end", _compile_tighten_low_end)
+register_compiler("widen_stereo", _compile_widen_stereo)
+register_compiler("darken_without_losing_width", _compile_darken_mix)
+register_compiler("reduce_repetition_fatigue", _compile_reduce_repetition)

package/mcp_server/semantic_moves/mix_moves.py

@@ -0,0 +1,157 @@
+"""Mix-domain semantic moves — musical intents for mixing and balance."""
+
+from .models import SemanticMove
+from .registry import register
+
+TIGHTEN_LOW_END = SemanticMove(
+    move_id="tighten_low_end",
+    family="mix",
+    intent="Tighten the low end — reduce sub mud, add bass definition",
+    targets={"weight": 0.4, "punch": 0.3, "clarity": 0.3},
+    protect={"warmth": 0.6},
+    risk_level="low",
+    compile_plan=[
+        {"tool": "get_master_spectrum", "params": {}, "description": "Check current sub/low balance"},
+        {"tool": "set_device_parameter", "params": {"description": "High-pass sub bass around 30-40 Hz"}, "description": "HP filter sub rumble"},
+        {"tool": "set_track_volume", "params": {"description": "Reduce sub bass volume 5-10% if sub > 50%"}, "description": "Reduce sub volume"},
+        {"tool": "set_device_parameter", "params": {"description": "Gentle saturation drive +2-4dB for harmonic definition"}, "description": "Add bass harmonics"},
+    ],
+    verification_plan=[
+        {"tool": "get_master_spectrum", "check": "sub band should decrease, low-mid stable"},
+        {"tool": "get_track_meters", "check": "bass track still producing audio"},
+    ],
+)
+
+WIDEN_STEREO = SemanticMove(
+    move_id="widen_stereo",
+    family="mix",
+    intent="Widen the stereo field without losing center focus",
+    targets={"width": 0.5, "clarity": 0.3, "depth": 0.2},
+    protect={"cohesion": 0.7},
+    risk_level="low",
+    compile_plan=[
+        {"tool": "analyze_mix", "params": {}, "description": "Check current stereo state"},
+        {"tool": "set_track_pan", "params": {"description": "Pan harmonic elements wider: +/-25-40%"}, "description": "Pan harmonics wider"},
+        {"tool": "set_track_pan", "params": {"description": "Pan percussion subtly: +/-10-20%"}, "description": "Pan perc subtly"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb send on wide elements +10-15%"}, "description": "Add depth to wide elements"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "all tracks producing stereo output"},
+        {"tool": "analyze_mix", "check": "stereo.mono_risk is false, side_activity > 0.1"},
+    ],
+)
+
+MAKE_PUNCHIER = SemanticMove(
+    move_id="make_punchier",
+    family="mix",
+    intent="Increase punch and transient impact across the mix",
+    targets={"punch": 0.5, "energy": 0.3, "contrast": 0.2},
+    protect={"clarity": 0.7, "warmth": 0.5},
+    risk_level="low",
+    compile_plan=[
+        {"tool": "get_track_meters", "params": {"include_stereo": True}, "description": "Read current levels"},
+        {"tool": "set_track_volume", "params": {"description": "Push drum track +5-8%"}, "description": "Push drum level"},
+        {"tool": "set_track_volume", "params": {"description": "Pull pad/texture -5-10%"}, "description": "Pull back pads"},
+        {"tool": "set_device_parameter", "params": {"description": "Lower Glue Compressor threshold 2-3dB if on master"}, "description": "Tighten master bus"},
+    ],
+    verification_plan=[
+        {"tool": "get_master_spectrum", "check": "mid and high-mid energy increased relative to before"},
+        {"tool": "get_track_meters", "check": "all tracks still producing audio"},
+    ],
+)
+
+DARKEN_MIX = SemanticMove(
+    move_id="darken_without_losing_width",
+    family="mix",
+    intent="Darken the mix tone by rolling off highs without collapsing stereo",
+    targets={"warmth": 0.5, "depth": 0.3, "width": 0.2},
+    protect={"width": 0.7, "clarity": 0.5},
+    risk_level="low",
+    compile_plan=[
+        {"tool": "get_master_spectrum", "params": {}, "description": "Check current tonal balance"},
+        {"tool": "set_device_parameter", "params": {"description": "Lower EQ/Auto Filter high shelf -2-4dB on bright tracks"}, "description": "Roll off highs"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb send on darkened elements for depth compensation"}, "description": "Compensate depth"},
+    ],
+    verification_plan=[
+        {"tool": "get_master_spectrum", "check": "high and air bands decreased, low-mid stable or increased"},
+        {"tool": "get_track_meters", "check": "all tracks producing audio (filter didn't kill signal)"},
+    ],
+)
+
+REDUCE_REPETITION = SemanticMove(
+    move_id="reduce_repetition_fatigue",
+    family="mix",
+    intent="Reduce repetition fatigue by adding organic movement and variation",
+    targets={"motion": 0.4, "novelty": 0.3, "contrast": 0.3},
+    protect={"cohesion": 0.6},
+    risk_level="medium",
+    compile_plan=[
+        {"tool": "apply_automation_shape", "params": {"curve_type": "perlin", "description": "Perlin noise on filter cutoff"}, "description": "Add organic filter drift"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "perlin", "description": "Perlin noise on send levels"}, "description": "Add depth movement"},
+        {"tool": "set_device_parameter", "params": {"description": "Increase Beat Repeat variation or chance"}, "description": "Add rhythmic variation"},
+    ],
+    verification_plan=[
+        {"tool": "get_track_meters", "check": "all tracks still producing audio"},
+        {"tool": "capture_audio", "check": "LRA > 2 LU (dynamic range should increase)"},
+    ],
+)
+
+MAKE_KICK_BASS_LOCK = SemanticMove(
+    move_id="make_kick_bass_lock",
+    family="mix",
+    intent="Make kick and bass work together — frequency separation + timing",
+    targets={"weight": 0.4, "punch": 0.3, "groove": 0.3},
+    protect={"warmth": 0.6, "cohesion": 0.7},
+    risk_level="low",
+    compile_plan=[
+        {"tool": "get_device_parameters", "params": {"description": "Read bass EQ/filter state"}, "description": "Inspect bass chain"},
+        {"tool": "set_device_parameter", "params": {"description": "High-pass bass at 40-60 Hz to clear space for kick sub"}, "description": "HP bass for kick clearance"},
+        {"tool": "set_device_parameter", "params": {"description": "Sidechain compressor or volume duck on bass from kick"}, "description": "Duck bass on kick hits"},
+    ],
+    verification_plan=[
+        {"tool": "get_master_spectrum", "check": "sub and low bands balanced, no masking"},
+        {"tool": "get_track_meters", "check": "both kick and bass tracks producing audio"},
+    ],
+)
+
+CREATE_BUILDUP_TENSION = SemanticMove(
+    move_id="create_buildup_tension",
+    family="arrangement",
+    intent="Create tension and energy buildup toward a drop or chorus",
+    targets={"tension": 0.5, "energy": 0.3, "contrast": 0.2},
+    protect={"clarity": 0.6},
+    risk_level="medium",
+    compile_plan=[
+        {"tool": "apply_gesture_template", "params": {"template_name": "tension_ratchet"}, "description": "Apply staged tension ratchet"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising HP filter over 4-8 bars"}, "description": "HP filter rise"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb send for wash effect"}, "description": "Add reverb wash"},
+    ],
+    verification_plan=[
+        {"tool": "get_emotional_arc", "check": "tension should increase before target section"},
+        {"tool": "get_track_meters", "check": "all tracks still producing audio"},
+    ],
+)
+
+SMOOTH_SCENE_HANDOFF = SemanticMove(
+    move_id="smooth_scene_handoff",
+    family="arrangement",
+    intent="Create a smooth transition between two scenes",
+    targets={"cohesion": 0.5, "motion": 0.3, "contrast": 0.2},
+    protect={"clarity": 0.7},
+    risk_level="low",
+    compile_plan=[
+        {"tool": "apply_gesture_template", "params": {"template_name": "pre_arrival_vacuum"}, "description": "Pull energy back before transition"},
+        {"tool": "apply_gesture_template", "params": {"template_name": "re_entry_spotlight"}, "description": "Spotlight returning elements"},
+    ],
+    verification_plan=[
+        {"tool": "get_emotional_arc", "check": "transition point should show energy dip then recovery"},
+    ],
+)
+
+# Register all moves
+for _move in [
+    TIGHTEN_LOW_END, WIDEN_STEREO, MAKE_PUNCHIER, DARKEN_MIX,
+    REDUCE_REPETITION, MAKE_KICK_BASS_LOCK, CREATE_BUILDUP_TENSION,
+    SMOOTH_SCENE_HANDOFF,
+]:
+    register(_move)

package/mcp_server/semantic_moves/models.py

@@ -0,0 +1,46 @@
+"""SemanticMove — high-level musical intent that compiles to tool sequences.
+
+A semantic move expresses WHAT to achieve musically, not HOW to achieve it
+parametrically. Each move has a compile_plan that decomposes into existing
+deterministic MCP tools, and a verification_plan that checks the result.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class SemanticMove:
+    """A musical action expressed as intent, not parameters."""
+
+    move_id: str
+    family: str  # mix, arrangement, transition, sound_design, performance
+    intent: str  # human-readable description of the musical goal
+    targets: dict = field(default_factory=dict)  # dimension -> weight
+    protect: dict = field(default_factory=dict)  # dimension -> threshold
+    risk_level: str = "low"  # low, medium, high
+    required_capabilities: list = field(default_factory=list)
+    compile_plan: list = field(default_factory=list)  # [{tool, params, description}]
+    verification_plan: list = field(default_factory=list)  # [{tool, check}]
+    confidence: float = 0.7
+
+    def to_dict(self) -> dict:
+        return {
+            "move_id": self.move_id,
+            "family": self.family,
+            "intent": self.intent,
+            "targets": self.targets,
+            "protect": self.protect,
+            "risk_level": self.risk_level,
+            "required_capabilities": self.required_capabilities,
+            "compile_plan_steps": len(self.compile_plan),
+            "confidence": self.confidence,
+        }
+
+    def to_full_dict(self) -> dict:
+        """Full representation including compile and verification plans."""
+        d = self.to_dict()
+        d["compile_plan"] = self.compile_plan
+        d["verification_plan"] = self.verification_plan
+        return d