livepilot 1.9.22 → 1.9.24

package/mcp_server/session_continuity/tools.py

@@ -0,0 +1,230 @@
+"""Session Continuity MCP tools — 7 tools for collaborative memory.
+
+  get_session_story — what the track was becoming, what changed, what's open
+  resume_last_intent — pick up where you left off
+  record_turn_resolution — log what happened in a creative turn
+  rank_by_taste_and_identity — rank candidates with separated taste/identity
+  open_creative_thread — open a new creative thread for exploration
+  list_open_creative_threads — list all open non-stale creative threads
+  explain_preference_vs_identity — explain taste vs identity tension
+"""
+
+from __future__ import annotations
+
+from fastmcp import Context
+
+from ..server import mcp
+from . import tracker
+
+
+@mcp.tool()
+def get_session_story(ctx: Context) -> dict:
+    """Get the narrative of the current session.
+
+    At the start of a resumed session, the agent can say what the track
+    was trying to become, what changed last time, and what still feels open.
+
+    Returns identity summary, recent turns, open creative threads,
+    and mood arc.
+    """
+    song_brain = _get_song_brain_dict()
+    story = tracker.get_session_story(song_brain)
+    return story.to_dict()
+
+
+@mcp.tool()
+def resume_last_intent(ctx: Context) -> dict:
+    """Resume the most recent unresolved creative intent.
+
+    Finds the latest open creative thread and suggests continuing it.
+    Stale threads (untouched for >30 minutes) are excluded.
+    """
+    return tracker.resume_last_intent()
+
+
+@mcp.tool()
+def record_turn_resolution(
+    ctx: Context,
+    request_text: str,
+    outcome: str = "accepted",
+    move_applied: str = "",
+    identity_effect: str = "",
+    user_sentiment: str = "neutral",
+) -> dict:
+    """Record what happened in a creative turn.
+
+    Call this after each significant creative action to build the
+    session story. Tracks outcomes, identity effects, and user sentiment.
+
+    request_text: what was requested
+    outcome: "accepted", "rejected", "modified", or "undone"
+    move_applied: which semantic move was used (if any)
+    identity_effect: "preserves", "evolves", "contrasts", or "resets"
+    user_sentiment: "loved", "liked", "neutral", "disliked", or "hated"
+    """
+    turn = tracker.record_turn_resolution(
+        request_text=request_text,
+        outcome=outcome,
+        move_applied=move_applied,
+        identity_effect=identity_effect,
+        user_sentiment=user_sentiment,
+    )
+    return turn.to_dict()
+
+
+@mcp.tool()
+def rank_by_taste_and_identity(
+    ctx: Context,
+    candidates: list[dict] | None = None,
+) -> dict:
+    """Rank candidates with separated taste and identity scoring.
+
+    Taste (cross-session preference) ranks options.
+    Identity (in-song) constrains/shapes options.
+    Explicit user instructions override both.
+
+    candidates: list of dicts with at least "id", "novelty_level",
+                and "identity_effect" fields
+
+    Returns ranked list with taste_score, identity_score, composite,
+    and explanations for each.
+    """
+    if not candidates:
+        return {"error": "No candidates provided", "rankings": []}
+
+    taste_graph = _get_taste_graph(ctx)
+    song_brain = _get_song_brain_dict()
+
+    rankings = tracker.rank_by_taste_and_identity(
+        candidates=candidates,
+        taste_graph=taste_graph,
+        song_brain=song_brain,
+    )
+
+    return {
+        "rankings": [r.to_dict() for r in rankings],
+        "note": "Identity has stronger weight inside a session; taste has stronger weight when choosing among viable options",
+    }
+
+
+@mcp.tool()
+def open_creative_thread(
+    ctx: Context,
+    description: str,
+    domain: str = "",
+    priority: float = 0.5,
+) -> dict:
+    """Open a new creative thread — an unresolved creative goal.
+
+    Use this to track intentions that span multiple actions, like
+    "develop the chorus hook" or "fix the transition energy."
+    Threads are surfaced by get_session_story and resume_last_intent.
+
+    description: what the creative goal is
+    domain: "arrangement", "sound_design", "mix", "harmony", "identity"
+    priority: 0-1 importance level
+    """
+    if not description.strip():
+        return {"error": "description cannot be empty"}
+
+    thread = tracker.open_thread(description, domain=domain, priority=priority)
+    return thread.to_dict()
+
+
+@mcp.tool()
+def list_open_creative_threads(ctx: Context) -> dict:
+    """List all open (non-stale) creative threads in the session.
+
+    Returns unresolved creative goals, abandoned directions worth
+    revisiting, and what the next best unresolved question is.
+    Stale threads (untouched for >30 minutes) are excluded.
+    """
+    threads = tracker.list_open_threads()
+
+    return {
+        "threads": [t.to_dict() for t in threads],
+        "thread_count": len(threads),
+        "next_best": threads[0].to_dict() if threads else None,
+        "note": "Threads decay after 30 minutes of inactivity",
+    }
+
+
+@mcp.tool()
+def explain_preference_vs_identity(
+    ctx: Context,
+    candidate_id: str = "",
+    novelty_level: float = 0.5,
+    identity_effect: str = "preserves",
+) -> dict:
+    """Explain how taste preference and song identity score a candidate.
+
+    Shows the tension between what the user tends to like (taste)
+    and what the current song needs (identity). Useful for understanding
+    why a variant was ranked the way it was.
+
+    candidate_id: the candidate to explain
+    novelty_level: 0-1 how novel the candidate is
+    identity_effect: "preserves", "evolves", "contrasts", or "resets"
+    """
+    taste_graph = _get_taste_graph(ctx)
+    song_brain = _get_song_brain_dict()
+
+    candidates = [{
+        "id": candidate_id,
+        "novelty_level": novelty_level,
+        "identity_effect": identity_effect,
+    }]
+
+    rankings = tracker.rank_by_taste_and_identity(
+        candidates=candidates,
+        taste_graph=taste_graph,
+        song_brain=song_brain,
+    )
+
+    if not rankings:
+        return {"error": "Could not rank candidate"}
+
+    r = rankings[0]
+    return {
+        "candidate_id": candidate_id,
+        "taste_score": r.taste_score,
+        "identity_score": r.identity_score,
+        "composite_score": r.composite_score,
+        "taste_explanation": r.taste_explanation,
+        "identity_explanation": r.identity_explanation,
+        "recommendation": r.recommendation,
+        "tension": (
+            "aligned" if abs(r.taste_score - r.identity_score) < 0.2
+            else "in tension — taste and identity disagree"
+        ),
+        "note": "Identity has stronger weight inside a session (0.65 vs 0.35)",
+    }
+
+
+# ── Helpers ───────────────────────────────────────────────────────
+
+
+def _get_song_brain_dict() -> dict:
+    try:
+        from ..song_brain.tools import _current_brain
+        if _current_brain is not None:
+            return _current_brain.to_dict()
+    except Exception as _e:
+        if __debug__:
+            import sys
+            print(f"LivePilot: SongBrain unavailable in session_continuity: {_e}", file=sys.stderr)
+    return {}
+
+
+def _get_taste_graph(ctx: Context) -> dict:
+    """Session-scoped taste graph — matches preview_studio pattern."""
+    try:
+        from ..memory.taste_graph import build_taste_graph
+        from ..memory.taste_memory import TasteMemoryStore
+        from ..memory.anti_memory import AntiMemoryStore
+        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).to_dict()
+    except Exception:
+        pass
+    return {}

package/mcp_server/session_continuity/tracker.py

@@ -0,0 +1,263 @@
+"""Session Continuity tracker — pure computation + in-memory state.
+
+Manages creative threads, turn resolutions, and session story.
+Separates taste (cross-session) from identity (in-song) ranking.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+from typing import Optional
+
+from .models import (
+    CreativeThread,
+    SessionStory,
+    TasteIdentityRanking,
+    TurnResolution,
+)
+
+
+# ── In-memory state ───────────────────────────────────────────────
+
+_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, _project_store
+    _story = SessionStory()
+    _threads = {}
+    _turns = []
+    _project_store = None
+
+
+# ── Session story ─────────────────────────────────────────────────
+
+
+def get_session_story(
+    song_brain: Optional[dict] = None,
+) -> SessionStory:
+    """Get the current session story with identity summary."""
+    song_brain = song_brain or {}
+
+    _story.identity_summary = song_brain.get("identity_core", "")
+    _story.threads = [t for t in _threads.values() if t.status == "open"]
+    _story.turns = _turns
+    _story.what_still_feels_open = [
+        t.description for t in _threads.values()
+        if t.status == "open" and not t.is_stale
+    ]
+
+    if _turns:
+        last = _turns[-1]
+        _story.what_changed_last = f"{last.request_text} → {last.outcome}"
+
+    return _story
+
+
+def resume_last_intent() -> dict:
+    """Resume the most recent unresolved creative intent."""
+    open_threads = [
+        t for t in _threads.values()
+        if t.status == "open" and not t.is_stale
+    ]
+
+    if not open_threads:
+        return {
+            "found": False,
+            "note": "No unresolved creative intents to resume",
+        }
+
+    # Sort by last touched (most recent first)
+    open_threads.sort(key=lambda t: t.last_touched_ms, reverse=True)
+    latest = open_threads[0]
+
+    return {
+        "found": True,
+        "thread_id": latest.thread_id,
+        "description": latest.description,
+        "domain": latest.domain,
+        "priority": latest.priority,
+        "suggestion": f"Continue working on: {latest.description}",
+    }
+
+
+# ── Turn tracking ─────────────────────────────────────────────────
+
+
+def record_turn_resolution(
+    request_text: str,
+    outcome: str = "accepted",
+    move_applied: str = "",
+    identity_effect: str = "",
+    user_sentiment: str = "neutral",
+) -> TurnResolution:
+    """Record what happened in a creative turn."""
+    now = int(time.time() * 1000)
+    turn_id = hashlib.sha256(f"{request_text}_{now}".encode()).hexdigest()[:10]
+
+    turn = TurnResolution(
+        turn_id=turn_id,
+        request_text=request_text,
+        outcome=outcome,
+        move_applied=move_applied,
+        identity_effect=identity_effect,
+        user_sentiment=user_sentiment,
+        timestamp_ms=now,
+    )
+    _turns.append(turn)
+
+    # Update mood arc
+    if user_sentiment in ("loved", "liked"):
+        _story.mood_arc.append("positive")
+    elif user_sentiment in ("disliked", "hated"):
+        _story.mood_arc.append("negative")
+    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
+
+
+# ── Creative threads ──────────────────────────────────────────────
+
+
+def open_thread(description: str, domain: str = "", priority: float = 0.5) -> CreativeThread:
+    """Open a new creative thread."""
+    now = int(time.time() * 1000)
+    thread_id = hashlib.sha256(f"{description}_{now}".encode()).hexdigest()[:10]
+
+    thread = CreativeThread(
+        thread_id=thread_id,
+        description=description,
+        domain=domain,
+        status="open",
+        priority=priority,
+        created_at_ms=now,
+        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
+
+
+def resolve_thread(thread_id: str) -> Optional[CreativeThread]:
+    """Mark a creative thread as resolved."""
+    thread = _threads.get(thread_id)
+    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
+
+
+def list_open_threads() -> list[CreativeThread]:
+    """List all open (non-stale) creative threads."""
+    return [
+        t for t in _threads.values()
+        if t.status == "open" and not t.is_stale
+    ]
+
+
+# ── Taste vs Identity ranking ────────────────────────────────────
+
+
+def rank_by_taste_and_identity(
+    candidates: list[dict],
+    taste_graph: Optional[dict] = None,
+    song_brain: Optional[dict] = None,
+) -> list[TasteIdentityRanking]:
+    """Rank candidates with separated taste and identity scoring.
+
+    Taste ranks options (cross-session preference).
+    Identity constrains/shapes options (in-song).
+    Identity has stronger weight inside a session.
+    """
+    taste_graph = taste_graph or {}
+    song_brain = song_brain or {}
+    results: list[TasteIdentityRanking] = []
+
+    for candidate in candidates:
+        cid = candidate.get("id", candidate.get("variant_id", ""))
+        novelty = candidate.get("novelty_level", 0.5)
+        identity_effect = candidate.get("identity_effect", "preserves")
+
+        # Taste score — how well does this fit cross-session preferences?
+        boldness_pref = taste_graph.get("transition_boldness", 0.5)
+        taste_score = 1.0 - abs(novelty - boldness_pref) * 0.8
+        taste_score = round(max(0.0, min(1.0, taste_score)), 3)
+
+        # Identity score — does this serve the current song?
+        identity_scores = {
+            "preserves": 0.9,
+            "evolves": 0.7,
+            "contrasts": 0.45,
+            "resets": 0.15,
+        }
+        identity_score = identity_scores.get(identity_effect, 0.5)
+
+        # Sacred element penalty — penalize non-preserving candidates
+        # that target sacred dimensions
+        sacred = song_brain.get("sacred_elements", [])
+        targets = candidate.get("targets_snapshot", {})
+        sacred_penalty = sum(
+            s.get("salience", 0.5) * 0.15
+            for s in sacred
+            if s.get("element_type") in targets and identity_effect != "preserves"
+        )
+        identity_score = max(0.0, identity_score - sacred_penalty)
+
+        # Composite: identity weighted more heavily within a session
+        composite = taste_score * 0.35 + identity_score * 0.65
+
+        # Explanations
+        taste_exp = (
+            f"{'Good' if taste_score > 0.6 else 'Moderate' if taste_score > 0.3 else 'Poor'} "
+            f"taste fit — novelty {novelty:.0%} vs preference {boldness_pref:.0%}"
+        )
+        identity_exp = (
+            f"Identity effect: {identity_effect} — "
+            f"{'safe for current song' if identity_score > 0.6 else 'risky for song identity'}"
+        )
+
+        results.append(TasteIdentityRanking(
+            candidate_id=cid,
+            taste_score=taste_score,
+            identity_score=identity_score,
+            composite_score=round(composite, 3),
+            taste_explanation=taste_exp,
+            identity_explanation=identity_exp,
+            recommendation="recommended" if composite > 0.6 else (
+                "consider" if composite > 0.4 else "caution"
+            ),
+        ))
+
+    results.sort(key=lambda r: r.composite_score, reverse=True)
+    return results

package/mcp_server/song_brain/__init__.py

@@ -0,0 +1,6 @@
+"""SongBrain — song identity modeling for Stage 2 Magic Layer.
+
+Captures the musical identity of the current piece:
+identity core, sacred elements, section purposes, energy arc,
+and payoff targets. Distinct from cross-session user taste.
+"""