livepilot 1.9.23 → 1.9.24

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
     {
       "name": "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",
-      "version": "1.9.23",
+      "version": "1.9.24",
       "author": {
         "name": "Pilot Studio"
       },

package/AGENTS.md

@@ -1,4 +1,4 @@
-# LivePilot v1.9.18 — Ableton Live 12
+# LivePilot v1.9.24 — Ableton Live 12
 
 ## Project
 - **Repo:** This directory (LivePilot)
@@ -43,4 +43,4 @@ When modifying .amxd attributes that Max editor won't persist (e.g., `openinpres
 4. Structure: 24-byte `ampf` header + `ptch` chunk + `mx@c` header + JSON patcher + frozen deps
 
 ## Tool Count
-Currently 257 tools. If adding/removing tools, update: README.md, package.json description, livepilot/.Codex-plugin/plugin.json, server.json, livepilot/skills/livepilot-core/SKILL.md, livepilot/skills/livepilot-core/references/overview.md, AGENTS.md, CHANGELOG.md, tests/test_tools_contract.py, docs/manual/index.md, docs/manual/tool-reference.md
+Currently 293 tools. If adding/removing tools, update: README.md, package.json description, livepilot/.Codex-plugin/plugin.json, livepilot/.claude-plugin/plugin.json, server.json, livepilot/skills/livepilot-core/SKILL.md, livepilot/skills/livepilot-core/references/overview.md, AGENTS.md, CLAUDE.md, CHANGELOG.md, tests/test_tools_contract.py, docs/manual/index.md, docs/manual/tool-reference.md

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 1.9.24 — Stability & Intelligence Upgrade (April 2026)
+
+### Truth and Boundaries (Wave 1)
+- **feat(runtime):** Capability contract — every advanced tool reports `full/fallback/analytical_only/unavailable` with confidence scores
+- **feat(runtime):** Command boundary audit — CI catches any `send_command()` targeting a non-existent Remote Script command
+- **fix(song_brain):** `get_motif_graph` now uses pure-Python engine instead of invalid TCP call
+- **fix(hook_hunter):** Same motif routing fix
+- **fix(musical_intelligence):** Same motif routing fix + `analyze_phrase_arc` now calls perception engine directly
+- **fix(memory):** `record_positive_preference` actually updates taste dimensions (was a silent no-op due to key mismatch)
+- **fix(metadata):** AGENTS.md synced to v1.9.23/293 tools, test docstring corrected
+
+### Unified Execution Layer (Wave 2)
+- **feat(runtime):** Execution router — classifies steps as `remote_command/bridge_command/mcp_tool/unknown`, dispatches correctly
+- **feat(semantic_moves):** `apply_semantic_move` explore mode uses execution router
+- **feat(preview_studio):** `render_preview_variant` uses execution router
+
+### Persistent Memory (Waves 2-3)
+- **feat(persistence):** Base persistent JSON store (atomic write, corruption recovery, thread-safe)
+- **feat(persistence):** Taste store at `~/.livepilot/taste.json` — move outcomes, novelty band, device affinity, anti-preferences survive restart
+- **feat(persistence):** Project store at `~/.livepilot/projects/<hash>/state.json` — threads, turns, Wonder outcomes per song
+- **feat(memory):** TasteGraph.record_move_outcome writes to persistent backing
+- **feat(session_continuity):** tracker flushes threads and turns to project store on write
+
+### Move Annotations (Wave 3)
+- **feat(semantic_moves):** All 20 moves annotated with explicit `backend` per compile_plan step
+- **test:** Static audit verifies all annotations match the execution router classifier
+
+### Intelligence Upgrade (Waves 3-4)
+- **feat(services):** Shared motif service — one entry point consumed by SongBrain, HookHunter, musical_intelligence
+- **feat(song_brain):** Evidence-weighted identity confidence (motif=0.4, composition=0.2, roles=0.15, scenes=0.15, moves=0.1)
+- **feat(song_brain):** `evidence_breakdown` field shows per-source contributions
+- **feat(hook_hunter):** Hooks carry `evidence_sources` (motif_recurrence, track_name, clip_reuse)
+- **feat(hook_hunter):** Section-placement analysis boosts hooks recurring across sections
+- **feat(detectors):** Motif appearing in >60% of sections triggers fatigue signal
+
+### Preview and Doctor (Wave 4)
+- **feat(preview_studio):** Three explicit preview modes: `audible_preview` (M4L+spectrum), `metadata_only_preview`, `analytical_preview`
+- **feat(preview_studio):** `bars` parameter used for audible preview playback duration
+- **feat(preview_studio):** `preview_mode` field in response — no ambiguity about what was measured
+- **feat(runtime):** Capability probe — 6-area runtime detection (Ableton, Remote Script, M4L, numpy, persistence, tier)
+
+### Release Infrastructure (Wave 5)
+- **feat(scripts):** `sync_metadata.py` — single source of truth for version and tool count, CI-checkable
+- **docs:** README Intelligence Layer section with all 12 engines described
+- **docs:** Manual index rewritten with three-layer architecture and 39-domain map
+
 ## 1.9.23-wonder-v1.5 — Wonder Mode V1.5: Stuck-Rescue Workflow (April 2026)
 
 ### Wonder Mode Redesign (292->293 tools)

package/README.md

@@ -77,6 +77,77 @@ All three feed into 293 deterministic tools that execute on Ableton's main threa
 
 ---
 
+## The Intelligence Layer
+
+Most MCP servers are tool collections — they execute commands. LivePilot is an **agentic production system** — it understands what a song is becoming, diagnoses when a session is stuck, generates real creative options, learns from your decisions, and tracks its own impact.
+
+This is the V2 intelligence layer: 12 engines that sit on top of the 293 tools and give the AI musical judgment, not just musical execution.
+
+### SongBrain — What the Song Is
+
+SongBrain builds a real-time model of the current session: what the defining idea is (identity core), what elements must not be casually damaged (sacred elements), what each section is trying to do emotionally (section purposes), and where the energy arc is heading. It answers the question every producer asks: *"What is this track?"*
+
+It detects when the song's identity is drifting — when recent edits are pulling the track away from what made it work. When identity confidence is high, the system makes bolder suggestions. When it's fragile, it protects what's there.
+
+### Taste Graph — What You Like
+
+The Taste Graph learns your production preferences across sessions. Not just "prefers reverb" — it tracks which move families you keep vs. undo (mix moves? arrangement moves?), which devices you gravitate toward, how experimental you want suggestions to be (your novelty band), and which dimensions you actively avoid.
+
+Every time you accept or reject a suggestion, the graph updates. Over time, it personalizes which creative options are offered and how they're ranked. Two producers using the same tools get different recommendations.
+
+### Semantic Moves — Musical Actions, Not Parameters
+
+A semantic move is a high-level musical intent — "add contrast," "tighten the low end," "build tension toward the chorus" — that compiles into a specific sequence of tool calls. The system has 20 moves across 4 families (mix, arrangement, transition, sound design), each with an executable plan.
+
+Moves carry risk levels, target dimensions, and protection thresholds. "Add a filter sweep build" targets energy and tension while protecting clarity. The AI doesn't just know what to do — it knows what it's risking.
+
+### Wonder Mode — Stuck-Rescue Workflow
+
+When a session is stuck — too many undos, polishing the same loop, no structural progress — Wonder Mode activates. It's not "surprise me." It's a structured diagnosis-and-rescue workflow:
+
+1. **Diagnose** — Why is the session stuck? Repeated undos? Overpolished loop? Missing contrast? Identity unclear? The stuckness detector analyzes the action history and classifies the problem.
+
+2. **Generate** — Based on the diagnosis, Wonder searches for semantic moves that address the specific problem. It enforces real distinctness — each variant must differ by move family or execution approach. If only one real option exists, it says so honestly instead of relabeling the same idea three times.
+
+3. **Preview** — Each executable variant can be applied, captured, and undone using Ableton's undo system. You hear what each option would actually sound like before committing.
+
+4. **Commit or Reject** — Choose one, and the system records it into taste and session continuity. Reject all, and the creative thread stays open for another attempt. No fake outcomes are recorded.
+
+### Creative Engines
+
+Six specialized engines handle different aspects of production intelligence:
+
+| Engine | What it does |
+|--------|-------------|
+| **Mix Engine** | Critic-driven mix analysis. Identifies masking, headroom issues, stereo problems. Plans corrective moves with before/after evaluation. |
+| **Sound Design Engine** | Analyzes patches for static timbre, missing modulation, weak transients. Suggests parameter moves and evaluates the result. |
+| **Transition Engine** | Classifies transition types (drop, build, breakdown). Scores transition quality and plans improvements using archetypes. |
+| **Composition Engine** | Analyzes song structure, detects motifs, infers section purposes, scores emotional arcs. Plans arrangement moves. |
+| **Performance Engine** | Safety-constrained suggestions for live performance. Knows which moves are safe during playback and which risk audio dropouts. |
+| **Reference Engine** | Distills principles from reference tracks. Maps those principles to your current session as concrete, actionable moves. |
+
+### Hook Hunter — Finding What Matters
+
+The Hook Hunter identifies the most salient musical idea in a session — the element listeners would remember. It ranks candidates by rhythmic distinctiveness, melodic contour, and repetition. Then it tracks whether hooks are being developed, neglected, or undermined by arrangement choices.
+
+When the hook is strong but underused, it flags it. When a transition fails to deliver the expected payoff, it diagnoses why.
+
+### Session Continuity — The Story of Your Session
+
+Session Continuity tracks what happened, what changed, and what's still unresolved. It maintains creative threads (open questions like "the chorus needs more lift") and records turn resolutions (what you tried, whether you kept it, how it affected identity).
+
+When you return to a project, the session story tells the AI: *"Last time, you were working on making the bridge darker. You tried three approaches and kept the filter sweep. The chorus lift thread is still open."*
+
+### Evaluation Loop — Verify Before Claiming Success
+
+Every creative engine follows the same discipline: **measure before, act, measure after, compare**. The evaluation system captures session state snapshots, runs the change, captures again, and scores the difference. If the change made things worse — more masking, lost headroom, identity drift — the system flags it before you move on.
+
+This closes the gap between "the AI did something" and "the AI did something that actually helped."
+
+<br>
+
+---
+
 ## Tools
 
 293 tools across 39 domains. Highlights below — [full catalog here](docs/manual/tool-catalog.md).
@@ -322,6 +393,29 @@ read_audio_metadata     Format, duration, sample rate, tags
 
 <br>
 
+### Agentic Intelligence — 83 tools
+
+The V2 intelligence layer. These tools don't just execute commands — they analyze, diagnose, plan, evaluate, and learn.
+
+| Domain | # | What it does |
+|--------|:-:|-------------|
+| Agent OS | 8 | session kernel, action ledger, capability state, routing, turn budget |
+| Composition | 9 | section analysis, motif detection, emotional arc, form planning, section transforms |
+| Evaluation | 1 | before/after evaluation with structured scoring |
+| Mix Engine | 6 | critic-driven mix analysis, issue detection, move planning, masking reports |
+| Sound Design | 5 | patch analysis, modulation planning, timbre scoring |
+| Transition Engine | 5 | transition classification, scoring, archetype-based planning |
+| Reference Engine | 5 | reference profiling, principle distillation, gap analysis, move mapping |
+| Translation Engine | 3 | cross-domain translation, issue detection |
+| Performance Engine | 5 | safety-constrained suggestions, safe move lists, scene handoff planning |
+| Song Brain | 4 | identity inference, sacred element detection, drift monitoring, section purposes |
+| Hook Hunter | 9 | hook detection, salience scoring, development strategies, neglect detection, phrase impact |
+| Stuckness Detector | 3 | momentum analysis, rescue classification, structured rescue workflows |
+| Wonder Mode | 3 | diagnosis-driven variant generation, taste-aware ranking, session discard |
+| Session Continuity | 7 | creative threads, turn resolution, taste vs identity ranking, session story |
+| Creative Constraints | 5 | constraint activation, reference-inspired variants, constrained generation |
+| Preview Studio | 5 | variant creation, preview rendering, comparison, commit, discard |
+
 > **[View all 293 tools →](docs/manual/tool-catalog.md)**
 
 <br>

package/livepilot/.Codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.23",
+  "version": "1.9.24",
   "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": {
     "name": "Pilot Studio"

package/livepilot/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.9.23",
+  "version": "1.9.24",
   "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": {
     "name": "Pilot Studio"

package/livepilot/skills/livepilot-core/references/overview.md

@@ -1,4 +1,4 @@
-# LivePilot v1.9.23 — Architecture & Tool Reference
+# LivePilot v1.9.24 — Architecture & Tool Reference
 
 Agentic production system for Ableton Live 12. 293 tools across 39 domains. Device atlas (280+ devices), spectral perception (M4L analyzer), technique memory, automation intelligence (16 curve types, 15 recipes), music theory (Krumhansl-Schmuckler, species counterpoint), generative algorithms (Euclidean rhythm, tintinnabuli, phase shift, additive process), neo-Riemannian harmony (PRL transforms, Tonnetz), MIDI file I/O.
 

package/livepilot/skills/livepilot-release/SKILL.md

@@ -105,6 +105,20 @@ Current: **39 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 - [ ] Remote script version matches MCP server version
 - [ ] All tests pass: `python3 -m pytest tests/ -v`
 
+## 11. Automated Checks
+
+- [ ] `python scripts/sync_metadata.py --check` — all metadata in sync
+- [ ] `python -m pytest tests/test_command_boundary_audit.py` — no invalid TCP targets
+- [ ] `python -m pytest tests/test_move_annotations.py` — all moves annotated
+- [ ] `python -m pytest tests/test_capability.py` — capability contract works
+- [ ] `python -m pytest tests/test_capability_probe.py` — doctor probe works
+
+## 12. Release Smoke Board
+
+- [ ] Run through `docs/manual/release-smoke-board.md` scenarios against real Ableton session
+- [ ] All preview modes correctly labeled (audible/metadata/analytical)
+- [ ] Persistence survives server restart
+
 ## Quick Verify Command
 
 ```bash

package/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": "0.3",
   "name": "livepilot",
   "display_name": "LivePilot — AI for Ableton Live",
-  "version": "1.9.23",
+  "version": "1.9.24",
   "description": "Agentic production system for Ableton Live 12. Make beats, mix tracks, design sounds, and arrange songs with 293 AI-powered tools.",
   "long_description": "LivePilot is an AI production assistant that connects directly to Ableton Live 12. It can create drum patterns, program basslines, write chord progressions, design sounds, mix your tracks, analyze your audio, and arrange full songs — all through natural language.\n\n**What it does:**\n- Creates MIDI clips with notes, chords, and rhythms\n- Loads instruments and effects from Ableton's browser\n- Shapes sounds by adjusting device parameters\n- Mixes with volume, panning, sends, and automation\n- Analyzes your mix with real-time spectral data\n- Remembers your production style across sessions\n\n**How it works:**\nLivePilot installs a Remote Script in Ableton that communicates with the AI over a local TCP connection. Everything runs on your machine — no audio leaves your computer.",
   "author": {

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.9.23"
+__version__ = "1.9.24"

package/mcp_server/hook_hunter/analyzer.py

@@ -82,9 +82,32 @@ def find_hook_candidates(
                 development_potential=0.5,
             ))
 
+    # 4. Section-placement analysis: boost hooks that appear in payoff sections
+    payoff_sections = {
+        s.get("label", "").lower()
+        for s in (composition.get("sections", []) if composition else [])
+        if s.get("is_payoff")
+    } or {"chorus", "drop", "hook"}
+
+    for c in candidates:
+        # Check if hook is present in payoff sections (via motif locations)
+        if c.hook_type == "melodic" and motif_data:
+            for motif in motif_data.get("motifs", []):
+                if motif.get("name", "") in c.hook_id:
+                    # Motif with high recurrence across sections = stronger hook
+                    c.memorability = min(1.0, c.memorability + motif.get("recurrence", 0) * 0.2)
+
     # Score all candidates
     for c in candidates:
         c.salience = _compute_salience(c)
+        # Add evidence sources
+        c.evidence_sources = []
+        if "motif_" in c.hook_id:
+            c.evidence_sources.append("motif_recurrence")
+        if "track_" in c.hook_id:
+            c.evidence_sources.append("track_name")
+        if "groove" in c.hook_id:
+            c.evidence_sources.append("clip_reuse")
 
     # Sort by salience
     candidates.sort(key=lambda c: c.salience, reverse=True)

package/mcp_server/hook_hunter/models.py

@@ -19,6 +19,7 @@ class HookCandidate:
     contrast_potential: float = 0.0  # 0-1 how well it stands out
     development_potential: float = 0.0  # 0-1 how much room to develop
     salience: float = 0.0  # composite score
+    evidence_sources: list[str] = field(default_factory=list)  # what data informed this
 
     def to_dict(self) -> dict:
         return asdict(self)

package/mcp_server/hook_hunter/tools.py

@@ -53,9 +53,11 @@ def _fetch_tracks_and_scenes(ctx: Context) -> tuple[list[dict], list[dict], dict
     except Exception:
         pass
 
-    # Fetch motif data from the motif engine for salience-based hook discovery
+    # Fetch motif data — via shared motif service
     try:
-        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, tracks)
+        motif_data = get_motif_data(notes_by_track)
     except Exception:
         pass  # Motif graph requires notes in clips; empty dict is valid fallback
 

package/mcp_server/memory/taste_graph.py

@@ -99,6 +99,9 @@ class TasteGraph:
 
     # ── Update methods ───────────────────────────────────────────────
 
+    # Persistent store reference (set by build_taste_graph when available)
+    _persistent_store: object = None
+
     def record_move_outcome(
         self, move_id: str, family: str, kept: bool, score: float = 0.0
     ) -> None:
@@ -120,6 +123,13 @@ class TasteGraph:
         self.evidence_count += 1
         self.last_updated_ms = now
 
+        # Write-back to persistent store
+        if self._persistent_store is not None:
+            try:
+                self._persistent_store.record_move_outcome(move_id, family, kept, score)
+            except Exception:
+                pass  # persistence is best-effort
+
     def record_device_use(self, device_name: str, positive: bool = True) -> None:
         """Update device affinity from usage."""
         now = int(time.time() * 1000)
@@ -245,10 +255,17 @@ class TasteGraph:
 def build_taste_graph(
     taste_store=None,   # TasteMemoryStore
     anti_store=None,    # AntiMemoryStore
+    persistent_store=None,  # PersistentTasteStore (optional)
 ) -> TasteGraph:
-    """Build a TasteGraph from existing memory stores."""
+    """Build a TasteGraph from existing memory stores.
+
+    When persistent_store is provided, hydrates move_family_scores,
+    device_affinities, and novelty_band from disk — these survive
+    server restart.
+    """
     graph = TasteGraph()
 
+    # Session-scoped dimensions (in-memory)
     if taste_store:
         for dim in taste_store.get_taste_dimensions():
             if dim.evidence_count > 0:
@@ -258,4 +275,54 @@ def build_taste_graph(
         for pref in anti_store.get_anti_preferences():
             graph.dimension_avoidances[pref.dimension] = pref.direction
 
+    # Persistent state (from disk)
+    if persistent_store is not None:
+        persisted = persistent_store.get_all()
+
+        # Move family scores
+        for move_id, outcome in persisted.get("move_outcomes", {}).items():
+            family = outcome.get("family", "")
+            if family and family not in graph.move_family_scores:
+                from .taste_graph import MoveFamilyScore
+                graph.move_family_scores[family] = MoveFamilyScore(family=family)
+            if family:
+                fam = graph.move_family_scores[family]
+                fam.kept_count += outcome.get("kept_count", 0)
+                fam.undone_count += outcome.get("undone_count", 0)
+                total = fam.kept_count + fam.undone_count
+                if total > 0:
+                    fam.score = round((fam.kept_count - fam.undone_count) / total, 3)
+
+        # Novelty band
+        graph.novelty_band = persisted.get("novelty_band", 0.5)
+
+        # Device affinities
+        for dev_name, dev_data in persisted.get("device_affinities", {}).items():
+            from .taste_graph import DeviceAffinity
+            graph.device_affinities[dev_name] = DeviceAffinity(
+                device_name=dev_name,
+                affinity=dev_data.get("affinity", 0.0),
+                use_count=dev_data.get("use_count", 0),
+            )
+
+        # Evidence count
+        graph.evidence_count = max(
+            graph.evidence_count, persisted.get("evidence_count", 0)
+        )
+
+        # Dimension weights from persistent store (merged, session takes precedence)
+        for dim, val in persisted.get("dimension_weights", {}).items():
+            if dim not in graph.dimension_weights:
+                graph.dimension_weights[dim] = val
+
+        # Anti-preferences from persistent store
+        for anti in persisted.get("anti_preferences", []):
+            dim = anti.get("dimension", "")
+            direction = anti.get("direction", "")
+            if dim and dim not in graph.dimension_avoidances:
+                graph.dimension_avoidances[dim] = direction
+
+    # Attach persistent store for write-back
+    graph._persistent_store = persistent_store
+
     return graph

package/mcp_server/memory/tools.py

@@ -189,12 +189,23 @@ def record_positive_preference(
     not just what they dislike.
     """
     taste_store = _get_taste_memory(ctx)
-    # Map to outcome signal
-    signal = f"{dimension}_{direction}_kept"
-    taste_store.update_from_outcome({"signal": signal})
+    # Find matching outcome signals for this dimension+direction
+    from ..memory.taste_memory import _OUTCOME_SIGNALS
+    matching_signals = []
+    dim_signals = _OUTCOME_SIGNALS.get(dimension, {})
+    for sig_name, adjustment in dim_signals.items():
+        # "increase" preference → match positive-adjustment signals (kept)
+        # "decrease" preference → match negative-adjustment signals (undone/less)
+        if direction == "increase" and adjustment > 0:
+            matching_signals.append(sig_name)
+        elif direction == "decrease" and adjustment < 0:
+            matching_signals.append(sig_name)
+    if matching_signals:
+        taste_store.update_from_outcome({"signals": matching_signals})
     return {
-        "recorded": True,
+        "recorded": bool(matching_signals),
         "dimension": dimension,
         "direction": direction,
+        "signals_matched": matching_signals,
         "evidence": evidence,
     }

package/mcp_server/musical_intelligence/detectors.py

@@ -96,9 +96,22 @@ def detect_repetition_fatigue(
     # 3. Motif fatigue from motif_graph
     if motif_graph:
         motifs = motif_graph.get("motifs", [])
+        num_sections = max(1, len(scenes))
         for motif in motifs:
             fatigue_risk = motif.get("fatigue_risk", 0)
-            if fatigue_risk > 0.6:
+            recurrence = motif.get("recurrence", 0)
+
+            # Motif appearing in >60% of sections = fatigue signal
+            if recurrence > 0.6 and num_sections >= 3:
+                adjusted_fatigue = max(fatigue_risk, recurrence * 0.8)
+                report.issues.append({
+                    "type": "motif_overuse",
+                    "severity": round(adjusted_fatigue, 3),
+                    "detail": f"Motif {motif.get('name', motif.get('motif_id', '?'))} appears in {recurrence:.0%} of sections",
+                    "motif_id": motif.get("motif_id", motif.get("name", "")),
+                    "evidence": "motif_recurrence",
+                })
+            elif fatigue_risk > 0.6:
                 report.issues.append({
                     "type": "motif_overuse",
                     "severity": fatigue_risk,

package/mcp_server/musical_intelligence/tools.py

@@ -45,10 +45,14 @@ def detect_repetition_fatigue(ctx: Context) -> dict:
             "clips": row,
         })
 
-    # Try to get motif graph for deeper analysis
+    # Motif data — via shared motif service
     motif_graph = None
     try:
-        motif_graph = ableton.send_command("get_motif_graph")
+        from ..services.motif_service import get_motif_data, fetch_notes_from_ableton
+        session_info = ableton.send_command("get_session_info", {})
+        track_list = session_info.get("tracks", [])
+        notes_by_track = fetch_notes_from_ableton(ableton, track_list)
+        motif_graph = get_motif_data(notes_by_track)
     except Exception:
         pass
 
@@ -171,17 +175,16 @@ def analyze_phrase_arc(
     loudness_data = None
     spectrum_data = None
 
+    # Direct Python calls to perception engine — not TCP
     try:
-        loudness_data = ableton.send_command("analyze_loudness_offline", {
-            "file_path": file_path, "detail": "full",
-        })
+        from ..tools._perception_engine import compute_loudness
+        loudness_data = compute_loudness(file_path, detail="full")
     except Exception:
         pass
 
     try:
-        spectrum_data = ableton.send_command("analyze_spectrum_offline_internal", {
-            "file_path": file_path,
-        })
+        from ..tools._perception_engine import compute_spectral
+        spectrum_data = compute_spectral(file_path)
     except Exception:
         pass
 

package/mcp_server/persistence/__init__.py

@@ -0,0 +1 @@
+"""Persistent storage for LivePilot state that survives server restart."""

package/mcp_server/persistence/base_store.py

@@ -0,0 +1,82 @@
+"""Persistent JSON store with atomic writes and corruption recovery.
+
+Follows the TechniqueStore pattern: lazy init, atomic tmp+rename,
+fsync to disk, corruption recovery via .corrupt rename.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+from pathlib import Path
+
+
+class PersistentJsonStore:
+    """Thread-safe, crash-safe JSON file store."""
+
+    def __init__(self, path: Path):
+        self._path = Path(path)
+        self._lock = threading.RLock()
+
+    @property
+    def path(self) -> Path:
+        return self._path
+
+    def read(self) -> dict:
+        """Read the store. Returns {} if missing or corrupt."""
+        with self._lock:
+            if not self._path.exists():
+                return {}
+            try:
+                return json.loads(self._path.read_text(encoding="utf-8"))
+            except (json.JSONDecodeError, OSError):
+                corrupt = self._path.with_suffix(self._path.suffix + ".corrupt")
+                try:
+                    self._path.rename(corrupt)
+                except OSError:
+                    pass
+                return {}
+
+    def write(self, data: dict) -> None:
+        """Atomically write data to disk."""
+        with self._lock:
+            self._path.parent.mkdir(parents=True, exist_ok=True)
+            tmp = self._path.with_suffix(".tmp")
+            try:
+                with open(tmp, "w", encoding="utf-8") as f:
+                    json.dump(data, f, indent=2, default=str)
+                    f.flush()
+                    os.fsync(f.fileno())
+                os.replace(str(tmp), str(self._path))
+            except OSError:
+                try:
+                    tmp.unlink(missing_ok=True)
+                except OSError:
+                    pass
+                raise
+
+    def update(self, updater) -> dict:
+        """Read-modify-write atomically. updater(data) -> modified data."""
+        with self._lock:
+            data = self._read_unlocked()
+            data = updater(data)
+            self._write_unlocked(data)
+            return data
+
+    def _read_unlocked(self) -> dict:
+        if not self._path.exists():
+            return {}
+        try:
+            return json.loads(self._path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def _write_unlocked(self, data: dict) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = self._path.with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, default=str)
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(str(tmp), str(self._path))