livepilot 1.9.23 → 1.9.24

package/mcp_server/semantic_moves/transition_moves.py

@@ -11,12 +11,12 @@ INCREASE_FORWARD_MOTION = SemanticMove(
     protect={"clarity": 0.6},
     risk_level="low",
     compile_plan=[
-        {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising filter cutoff over 4 bars"}, "description": "Rising filter sweep"},
-        {"tool": "set_track_volume", "params": {"description": "Push rhythm elements +5-8%"}, "description": "Push rhythm forward"},
-        {"tool": "apply_automation_shape", "params": {"curve_type": "linear", "description": "Rising reverb send for anticipation"}, "description": "Build reverb wash"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising filter cutoff over 4 bars"}, "description": "Rising filter sweep", "backend": "mcp_tool"},
+        {"tool": "set_track_volume", "params": {"description": "Push rhythm elements +5-8%"}, "description": "Push rhythm forward", "backend": "remote_command"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "linear", "description": "Rising reverb send for anticipation"}, "description": "Build reverb wash", "backend": "mcp_tool"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "energy increasing, all tracks alive"},
+        {"tool": "get_track_meters", "check": "energy increasing, all tracks alive", "backend": "remote_command"},
     ],
 )
 
@@ -28,13 +28,13 @@ OPEN_CHORUS = SemanticMove(
     protect={"clarity": 0.6, "cohesion": 0.5},
     risk_level="medium",
     compile_plan=[
-        {"tool": "set_track_volume", "params": {"description": "Push all melodic tracks +10-15%"}, "description": "Push chorus energy"},
-        {"tool": "set_track_pan", "params": {"description": "Widen stereo field on chords/pads"}, "description": "Widen stereo"},
-        {"tool": "set_track_send", "params": {"description": "Increase reverb/delay sends for spaciousness"}, "description": "Add space"},
+        {"tool": "set_track_volume", "params": {"description": "Push all melodic tracks +10-15%"}, "description": "Push chorus energy", "backend": "remote_command"},
+        {"tool": "set_track_pan", "params": {"description": "Widen stereo field on chords/pads"}, "description": "Widen stereo", "backend": "remote_command"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb/delay sends for spaciousness"}, "description": "Add space", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "overall energy increased, stereo field wider"},
-        {"tool": "analyze_mix", "check": "no clipping, stereo.mono_risk is false"},
+        {"tool": "get_track_meters", "check": "overall energy increased, stereo field wider", "backend": "remote_command"},
+        {"tool": "analyze_mix", "check": "no clipping, stereo.mono_risk is false", "backend": "mcp_tool"},
     ],
 )
 
@@ -46,12 +46,12 @@ CREATE_BREAKDOWN = SemanticMove(
     protect={"cohesion": 0.5},
     risk_level="medium",
     compile_plan=[
-        {"tool": "set_track_volume", "params": {"description": "Pull drums to 20-30%"}, "description": "Strip drums"},
-        {"tool": "set_track_volume", "params": {"description": "Pull bass to 30-40%"}, "description": "Reduce bass"},
-        {"tool": "set_track_send", "params": {"description": "Increase reverb send on remaining elements"}, "description": "Add reverb depth"},
+        {"tool": "set_track_volume", "params": {"description": "Pull drums to 20-30%"}, "description": "Strip drums", "backend": "remote_command"},
+        {"tool": "set_track_volume", "params": {"description": "Pull bass to 30-40%"}, "description": "Reduce bass", "backend": "remote_command"},
+        {"tool": "set_track_send", "params": {"description": "Increase reverb send on remaining elements"}, "description": "Add reverb depth", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "energy significantly reduced, at least one element still prominent"},
+        {"tool": "get_track_meters", "check": "energy significantly reduced, at least one element still prominent", "backend": "remote_command"},
     ],
 )
 
@@ -63,11 +63,11 @@ BRIDGE_SECTIONS = SemanticMove(
     protect={"clarity": 0.6},
     risk_level="low",
     compile_plan=[
-        {"tool": "apply_automation_shape", "params": {"curve_type": "cosine", "description": "Gentle filter sweep across bridge"}, "description": "Bridge filter motion"},
-        {"tool": "set_track_volume", "params": {"description": "Gentle volume crossfade between section elements"}, "description": "Crossfade elements"},
+        {"tool": "apply_automation_shape", "params": {"curve_type": "cosine", "description": "Gentle filter sweep across bridge"}, "description": "Bridge filter motion", "backend": "mcp_tool"},
+        {"tool": "set_track_volume", "params": {"description": "Gentle volume crossfade between section elements"}, "description": "Crossfade elements", "backend": "remote_command"},
     ],
     verification_plan=[
-        {"tool": "get_track_meters", "check": "smooth level transition, no dropouts"},
+        {"tool": "get_track_meters", "check": "smooth level transition, no dropouts", "backend": "remote_command"},
     ],
 )
 

package/mcp_server/services/__init__.py

@@ -0,0 +1 @@
+"""Shared services consumed by multiple domains."""

package/mcp_server/services/motif_service.py

@@ -0,0 +1,67 @@
+"""Shared motif service — one entry point for all motif consumers.
+
+SongBrain, HookHunter, and musical_intelligence all import from here
+instead of making ad-hoc calls to the motif engine or TCP.
+
+Pure computation — no I/O. Callers provide pre-fetched data.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+def get_motif_data(
+    notes_by_track: dict[int, list[dict]],
+) -> dict:
+    """Extract motif data from pre-fetched notes.
+
+    Args:
+        notes_by_track: {track_index: [note_dicts]} from get_notes calls
+
+    Returns:
+        Motif analysis dict with motifs, motif_count, tracks_analyzed.
+        Returns empty result if no notes or engine unavailable.
+    """
+    if not notes_by_track:
+        return {"motifs": [], "motif_count": 0, "tracks_analyzed": 0}
+
+    try:
+        from ..tools import _motif_engine as motif_engine
+        motifs = motif_engine.detect_motifs(notes_by_track)
+        return {
+            "motifs": [m.to_dict() for m in motifs],
+            "motif_count": len(motifs),
+            "tracks_analyzed": len(notes_by_track),
+        }
+    except Exception:
+        return {"motifs": [], "motif_count": 0, "tracks_analyzed": 0}
+
+
+def fetch_notes_from_ableton(ableton, tracks: list[dict], max_clips: int = 8) -> dict[int, list[dict]]:
+    """Fetch notes from Ableton for motif analysis.
+
+    This is the I/O helper — calls get_notes through valid TCP commands.
+    Callers pass the ableton connection; this function does the fetching.
+    """
+    notes_by_track: dict[int, list[dict]] = {}
+    for track in tracks:
+        t_idx = track.get("index", 0)
+        if not track.get("has_midi_input", False) and not any(
+            kw in track.get("name", "").lower()
+            for kw in ("midi", "synth", "bass", "lead", "pad", "keys", "piano", "chord")
+        ):
+            continue
+        track_notes = []
+        for clip_idx in range(max_clips):
+            try:
+                result = ableton.send_command("get_notes", {
+                    "track_index": t_idx,
+                    "clip_index": clip_idx,
+                })
+                track_notes.extend(result.get("notes", []))
+            except Exception:
+                pass
+        if track_notes:
+            notes_by_track[t_idx] = track_notes
+    return notes_by_track

package/mcp_server/session_continuity/tracker.py

@@ -23,14 +23,22 @@ from .models import (
 _story = SessionStory()
 _threads: dict[str, CreativeThread] = {}
 _turns: list[TurnResolution] = []
+_project_store = None  # Optional PersistentProjectStore
+
+
+def set_project_store(store) -> None:
+    """Attach a persistent project store for flush-on-write."""
+    global _project_store
+    _project_store = store
 
 
 def reset_story() -> None:
     """Reset session story (for testing)."""
-    global _story, _threads, _turns
+    global _story, _threads, _turns, _project_store
     _story = SessionStory()
     _threads = {}
     _turns = []
+    _project_store = None
 
 
 # ── Session story ─────────────────────────────────────────────────
@@ -117,6 +125,13 @@ def record_turn_resolution(
     else:
         _story.mood_arc.append("neutral")
 
+    # Flush to persistent store
+    if _project_store is not None:
+        try:
+            _project_store.save_turn(turn.to_dict())
+        except Exception:
+            pass
+
     return turn
 
 
@@ -138,6 +153,14 @@ def open_thread(description: str, domain: str = "", priority: float = 0.5) -> Cr
         last_touched_ms=now,
     )
     _threads[thread_id] = thread
+
+    # Flush to persistent store
+    if _project_store is not None:
+        try:
+            _project_store.save_thread(thread.to_dict())
+        except Exception:
+            pass
+
     return thread
 
 
@@ -147,6 +170,11 @@ def resolve_thread(thread_id: str) -> Optional[CreativeThread]:
     if thread:
         thread.status = "resolved"
         thread.last_touched_ms = int(time.time() * 1000)
+        if _project_store is not None:
+            try:
+                _project_store.save_thread(thread.to_dict())
+            except Exception:
+                pass
     return thread
 
 

package/mcp_server/song_brain/builder.py

@@ -74,16 +74,43 @@ def build_song_brain(
 
     drift_risk = _estimate_drift_risk(recent_moves, sacred)
 
+    # Evidence-weighted confidence adjustment
+    # Weights: motif=0.4, composition=0.2, role_graph=0.15, scenes=0.15, recent_moves=0.1
+    evidence_weights = {
+        "motif_data": 0.4,
+        "composition_analysis": 0.2,
+        "role_graph": 0.15,
+        "scenes": 0.15,
+        "recent_moves": 0.1,
+    }
+    evidence_score = sum(
+        weight for source, weight in evidence_weights.items()
+        if built_from.get(source, False)
+    )
+    # Adjust identity confidence by evidence availability
+    adjusted_confidence = round(identity_confidence * (0.4 + 0.6 * evidence_score), 3)
+
+    evidence_breakdown = {
+        "raw_confidence": identity_confidence,
+        "evidence_score": round(evidence_score, 3),
+        "adjusted_confidence": adjusted_confidence,
+        "sources": {
+            source: {"available": built_from.get(source, False), "weight": weight}
+            for source, weight in evidence_weights.items()
+        },
+    }
+
     return SongBrain(
         brain_id=brain_id,
         identity_core=identity_core,
-        identity_confidence=identity_confidence,
+        identity_confidence=adjusted_confidence,
         sacred_elements=sacred,
         section_purposes=sections,
         energy_arc=energy_arc,
         identity_drift_risk=drift_risk,
         payoff_targets=payoff_targets,
         open_questions=open_questions,
+        evidence_breakdown=evidence_breakdown,
         built_from=built_from,
     )
 

package/mcp_server/song_brain/models.py

@@ -84,6 +84,9 @@ class SongBrain:
     # Open questions the song has not resolved
     open_questions: list[OpenQuestion] = field(default_factory=list)
 
+    # Evidence breakdown — what data informed each inference
+    evidence_breakdown: dict = field(default_factory=dict)
+
     # Metadata
     built_from: dict = field(default_factory=dict)  # what data sources contributed
 
@@ -98,6 +101,7 @@ class SongBrain:
             "identity_drift_risk": self.identity_drift_risk,
             "payoff_targets": self.payoff_targets,
             "open_questions": [q.to_dict() for q in self.open_questions],
+            "evidence_breakdown": self.evidence_breakdown,
             "built_from": self.built_from,
         }
 

package/mcp_server/song_brain/tools.py

@@ -88,9 +88,11 @@ def _fetch_session_data(ctx: Context) -> dict:
     except Exception:
         pass
 
-    # Motif data — from the motif engine if notes exist
+    # Motif data — via shared motif service (pure-Python, not TCP)
     try:
-        data["motif_data"] = ableton.send_command("get_motif_graph")
+        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:
         pass  # Motif graph requires notes in clips; empty is valid
 
@@ -147,6 +149,21 @@ def build_song_brain(ctx: Context) -> dict:
     Returns the full SongBrain as a dict.
     """
     data = _fetch_session_data(ctx)
+
+    # 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={
+            "session_info": bool(data.get("session_info", {}).get("tempo")),
+            "scenes": bool(data.get("scenes")),
+            "tracks": bool(data.get("tracks")),
+            "motif_data": bool(data.get("motif_data")),
+            "composition_analysis": bool(data.get("composition_analysis")),
+            "role_graph": bool(data.get("role_graph")),
+        },
+    )
+
     brain = builder.build_song_brain(
         session_info=data["session_info"],
         scenes=data["scenes"],
@@ -161,6 +178,7 @@ def build_song_brain(ctx: Context) -> dict:
     return {
         **brain.to_dict(),
         "summary": brain.summary,
+        "capability": cap.to_dict(),
     }
 
 

package/mcp_server/wonder_mode/tools.py

@@ -29,9 +29,14 @@ def _get_taste_graph(ctx: Context):
         from ..memory.taste_graph import build_taste_graph
         from ..memory.taste_memory import TasteMemoryStore
         from ..memory.anti_memory import AntiMemoryStore
+        from ..persistence.taste_store import PersistentTasteStore
         taste_store = ctx.lifespan_context.setdefault("taste_memory", TasteMemoryStore())
         anti_store = ctx.lifespan_context.setdefault("anti_memory", AntiMemoryStore())
-        return build_taste_graph(taste_store=taste_store, anti_store=anti_store)
+        persistent = ctx.lifespan_context.setdefault("persistent_taste", PersistentTasteStore())
+        return build_taste_graph(
+            taste_store=taste_store, anti_store=anti_store,
+            persistent_store=persistent,
+        )
     except Exception:
         pass
     return None

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.23",
+  "version": "1.9.24",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 293 tools, 39 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": "Pilot Studio",

package/remote_script/LivePilot/__init__.py

@@ -5,7 +5,7 @@ Entry point for the ControlSurface. Ableton calls create_instance(c_instance)
 when this script is selected in Preferences > Link, Tempo & MIDI.
 """
 
-__version__ = "1.9.23"
+__version__ = "1.9.24"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/scripts/sync_metadata.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Metadata sync — single source of truth for version and tool count.
+
+Reads version from package.json, tool count from test_tools_contract.py,
+and verifies all known locations are in sync.
+
+Usage:
+    python scripts/sync_metadata.py --check   # verify, exit 1 if stale
+    python scripts/sync_metadata.py --fix     # auto-fix stale references
+"""
+
+import json
+import re
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def get_version() -> str:
+    """Read version from package.json (source of truth)."""
+    pkg = json.loads((ROOT / "package.json").read_text())
+    return pkg["version"]
+
+
+def get_tool_count() -> int:
+    """Read tool count from test_tools_contract.py assertion."""
+    src = (ROOT / "tests" / "test_tools_contract.py").read_text()
+    match = re.search(r"assert len\(tools\) == (\d+)", src)
+    if match:
+        return int(match.group(1))
+    raise ValueError("Could not find tool count assertion in test_tools_contract.py")
+
+
+# Files that must contain the version string
+VERSION_FILES = [
+    "package.json",
+    "server.json",
+    "manifest.json",
+    "livepilot/.claude-plugin/plugin.json",
+    "livepilot/.Codex-plugin/plugin.json",
+    ".claude-plugin/marketplace.json",
+    "mcp_server/__init__.py",
+    "remote_script/LivePilot/__init__.py",
+    "CLAUDE.md",
+    "AGENTS.md",
+    "livepilot/skills/livepilot-core/references/overview.md",
+    "docs/M4L_BRIDGE.md",
+]
+
+# Files that must contain the tool count
+TOOL_COUNT_FILES = [
+    "README.md",
+    "package.json",
+    "server.json",
+    "CLAUDE.md",
+    "AGENTS.md",
+    "CONTRIBUTING.md",
+    "livepilot/.claude-plugin/plugin.json",
+    "livepilot/.Codex-plugin/plugin.json",
+    "livepilot/skills/livepilot-core/SKILL.md",
+    "livepilot/skills/livepilot-core/references/overview.md",
+    "docs/manual/index.md",
+    "docs/manual/tool-reference.md",
+    "docs/manual/tool-catalog.md",
+]
+
+
+def check_version(version: str) -> list[str]:
+    """Check all version files for staleness."""
+    issues = []
+    for rel_path in VERSION_FILES:
+        path = ROOT / rel_path
+        if not path.exists():
+            continue
+        content = path.read_text()
+        if version not in content:
+            # Find what version IS there
+            old = re.search(r"1\.\d+\.\d+", content)
+            old_ver = old.group(0) if old else "???"
+            if old_ver != version:
+                issues.append(f"  {rel_path}: has {old_ver}, expected {version}")
+    return issues
+
+
+def check_tool_count(count: int) -> list[str]:
+    """Check all tool count files for staleness."""
+    issues = []
+    count_str = str(count)
+    for rel_path in TOOL_COUNT_FILES:
+        path = ROOT / rel_path
+        if not path.exists():
+            continue
+        content = path.read_text()
+        # Look for "N tools" pattern
+        matches = re.findall(r"(\d+)\s+tools", content)
+        for m in matches:
+            if m != count_str and int(m) > 250:  # ignore subset counts like "210 tools"
+                issues.append(f"  {rel_path}: has '{m} tools', expected '{count_str} tools'")
+                break
+    return issues
+
+
+def main():
+    mode = sys.argv[1] if len(sys.argv) > 1 else "--check"
+
+    version = get_version()
+    tool_count = get_tool_count()
+
+    print(f"Source of truth: version={version}, tools={tool_count}")
+
+    version_issues = check_version(version)
+    count_issues = check_tool_count(tool_count)
+
+    all_issues = version_issues + count_issues
+
+    if all_issues:
+        print(f"\nFound {len(all_issues)} stale reference(s):")
+        for issue in all_issues:
+            print(issue)
+        if mode == "--check":
+            sys.exit(1)
+        elif mode == "--fix":
+            print("\n--fix mode not yet implemented. Fix manually.")
+            sys.exit(1)
+    else:
+        print("All metadata in sync.")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()