livepilot 1.12.2 → 1.13.0

package/CHANGELOG.md

@@ -1,5 +1,87 @@
 # Changelog
 
+## 1.13.0 — Branch-native architecture (April 20 2026)
+
+Twelve-PR migration from "match request → pick move → compile move" to
+"understand intent → generate branches → compile branches → compare".
+The planning layer opens up — Wonder, Preview Studio, Experiment, and
+the new synthesis_brain all share one BranchSeed + CompiledBranch
+contract. Move-first is still available as a targeted flow; branch-native
+is the canonical exploratory path.
+
+**No tool count change** (still 398). **Domain count 51 → 52**
+(added `synthesis_brain`). **+175 new tests** across 9 new files
+(2206 → 2387 passing, 1 skipped, 0 failures).
+
+### New substrate (additive, non-breaking)
+
+- **`mcp_server/branches/`** (PR1) — shared `BranchSeed` and
+  `CompiledBranch` types with `seed_from_move_id` / `freeform_seed` /
+  `analytical_seed` factories. `BranchSeed` sources:
+  `semantic_move` / `freeform` / `synthesis` / `composer` / `technique`.
+- **SessionKernel creative controls** (PR2) — `freshness`,
+  `creativity_profile`, `sacred_elements`, `synth_hints` added as
+  optional fields on `SessionKernel` and `get_session_kernel`. Legacy
+  callers see zero behavior change.
+- **ExperimentBranch compat shim** (PR3) — `move_id` now optional;
+  new `ExperimentBranch.from_seed()` classmethod and
+  `create_experiment_from_seeds(seeds=[...], compiled_plans=[...])`
+  entry point. Legacy `create_experiment(move_ids=...)` keeps working
+  and internally delegates via `seed_from_move_id`.
+- **Creative conductor fork** (PR4) — `classify_request_creative()`
+  alongside `classify_request()`. Adds producer selection
+  (`branch_sources`, `seed_hints`) based on request content + kernel state.
+- **`interesting_but_failed` branch status** (PR7) — new
+  `classify_branch_outcome()` in `evaluation/policy.py`. Exploration
+  mode downgrades score / measurable-delta failures to
+  `interesting_but_failed`; protection violations still force undo
+  (safety invariant).
+- **Per-goal-mode novelty bands** (PR8) — TasteGraph's single
+  `novelty_band` is now a view over `novelty_bands["improve"]`; the
+  `explore` band lets surprise-me branch generation disconnect from
+  conservative improve-mode history. `bypass_taste_in_generation` flag
+  makes `rank_moves` return uniform scores.
+
+### Branch-native producers
+
+- **Wonder branch assembler** (PR6) — `generate_branch_seeds()` emits
+  seeds from four sources: semantic_move, technique (session memory),
+  sacred-element inversion (freshness-gated), and corpus hints.
+  `enter_wonder_mode` now surfaces `branch_seeds` alongside variants.
+- **`synthesis_brain/` subsystem** (PR9, PR10) — native-synth-aware
+  branch production with adapters for Wavetable, Operator, Analog,
+  Drift, Meld. `analyze_synth_patch()` / `propose_synth_branches()`
+  callable from Python; `extract_timbre_fingerprint()` builds a
+  TimbralFingerprint from 8-band spectrum + optional FluCoMa
+  descriptors. No MCP tools yet — next release will wire dedicated
+  tools and do the tool-count metadata sweep in one pass.
+- **Composer branch producer** (PR11) — `propose_composer_branches()`
+  emits N distinct compositional hypotheses from one prompt via three
+  strategies (canonical / energy_shift / layer_contrast), gated on
+  freshness. Each branch ships a pre-compiled scaffolding plan.
+
+### Docs refactor
+
+- **Skills + command guides thinned** (PR5) — `livepilot-core/SKILL.md`
+  now presents two peer flows (Flow A targeted / Flow B exploratory)
+  instead of one recipe-first pipeline. `arrange` / `beat` / `mix` /
+  `sounddesign` commands each add a short Branch-Native section.
+- **Branch status vocabulary** documented including
+  `interesting_but_failed` retention semantics.
+
+### Migration notes for callers
+
+- All additions are optional-param / new-function shaped. Any code
+  reading `branch.move_id` keeps working because `ExperimentBranch`
+  mirrors `seed.move_id` there. Any code calling
+  `create_experiment(move_ids=...)` keeps its exact behavior.
+- If you have persistent state on disk (`~/.livepilot/taste.json`):
+  v1.13 migrates `novelty_band` (flat float) to `novelty_bands` (dict)
+  on first read. Old clients reading the file still see the flat field.
+- Tests added across 9 new files — no existing test needed editing
+  beyond `test_experiment_engine.py` (which gains PR3 coverage but
+  keeps every pre-PR3 test passing).
+
 ## 1.12.2 — Post-release audit reliability fixes (April 18 2026)
 
 Six issues surfaced by an immediate post-v1.12.0 deep audit (parallel

package/README.md

@@ -17,7 +17,7 @@
 
 <p align="center">
   An agentic production system for Ableton Live 12.<br>
-  398 tools. 51 domains. Device atlas. Splice integration. Auto-composition. Spectral perception. Technique memory.
+  398 tools. 52 domains. Device atlas. Splice integration. Auto-composition. Spectral perception. Technique memory.
 </p>
 
 <br>
@@ -80,7 +80,7 @@ Most MCP servers are tool collections — they execute commands. LivePilot is an
 │                           ▼                                          │
 │                  ┌─────────────────┐                                  │
 │                  │   398 MCP Tools  │                                  │
-│                  │   51 domains     │                                  │
+│                  │   52 domains     │                                  │
 │                  └────────┬────────┘                                  │
 │                           │                                          │
 │           Remote Script ──┤── TCP 9878                                │
@@ -172,7 +172,7 @@ Every engine follows: **measure before → act → measure after → compare**.
 
 ## Tools
 
-398 tools across 51 domains. Highlights below — [full catalog here](docs/manual/tool-catalog.md).
+398 tools across 52 domains. Highlights below — [full catalog here](docs/manual/tool-catalog.md).
 
 <br>
 

package/m4l_device/livepilot_bridge.js

@@ -95,7 +95,7 @@ function anything() {
 function dispatch(cmd, args) {
     switch(cmd) {
         case "ping":
-            send_response({"ok": true, "version": "1.12.2"});
+            send_response({"ok": true, "version": "1.13.0"});
             break;
         case "get_params":
             cmd_get_params(args);

package/mcp_server/__init__.py

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

package/mcp_server/branches/__init__.py

@@ -0,0 +1,32 @@
+"""Branch-native types — the shared substrate for Wonder, Preview Studio,
+Experiment, and future producers (synthesis_brain, composer).
+
+A BranchSeed is a producer-emitted creative intent (pre-compilation).
+A CompiledBranch pairs a seed with a concrete plan ready for the execution
+router. compiled_plan=None ⇒ analytical-only (directional suggestion).
+
+This module is pure types + factory helpers. No I/O, no side effects, no
+imports from other mcp_server subsystems.
+"""
+
+from .types import (
+    BranchSeed,
+    CompiledBranch,
+    BranchSource,
+    RiskLabel,
+    NoveltyLabel,
+    seed_from_move_id,
+    freeform_seed,
+    analytical_seed,
+)
+
+__all__ = [
+    "BranchSeed",
+    "CompiledBranch",
+    "BranchSource",
+    "RiskLabel",
+    "NoveltyLabel",
+    "seed_from_move_id",
+    "freeform_seed",
+    "analytical_seed",
+]

package/mcp_server/branches/types.py

@@ -0,0 +1,230 @@
+"""Branch-native types.
+
+Design (see docs/specs/2026-03-17-livepilot-design.md and the branch-native
+migration plan):
+
+- Producers (Wonder, synthesis_brain, composer, technique memory) emit
+  BranchSeed objects expressing creative intent. A seed carries a hypothesis,
+  a source label, a distinctness reason, and novelty/risk labels — but no
+  executable plan yet.
+- A compiler turns a seed into a CompiledBranch by attaching a plan. For
+  source="semantic_move" seeds, the existing semantic_moves.compiler is used.
+  For freeform/synthesis/composer seeds, the producer supplies the plan.
+- CompiledBranch is the canonical post-compilation shape. PreviewVariant
+  and ExperimentBranch will migrate to thin wrappers over CompiledBranch
+  in later PRs; this PR only introduces the types.
+
+compiled_plan=None means analytical_only — the branch is a directional
+suggestion with no executable path. This case already exists in Wonder
+(build_analytical_variant); the branch-native schema promotes it to a
+first-class concept across the whole system.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import asdict, dataclass, field
+from typing import Literal, Optional
+
+
+BranchSource = Literal[
+    "semantic_move",  # compiled via semantic_moves.compiler
+    "freeform",       # producer supplies the compiled plan directly
+    "synthesis",      # from synthesis_brain (PR9+)
+    "composer",       # from composer branch-native path (PR11)
+    "technique",      # from technique memory replay
+]
+RiskLabel = Literal["low", "medium", "high"]
+NoveltyLabel = Literal["safe", "strong", "unexpected"]
+
+
+@dataclass
+class BranchSeed:
+    """Pre-compilation creative intent.
+
+    Distinctness between branches is checked at seed layer — two seeds with
+    the same (source, hypothesis_hash, affected_scope_hash) are not distinct.
+
+    Fields:
+      seed_id: stable identifier. For semantic_move seeds, derived from move_id.
+      source: producer category.
+      move_id: populated when source="semantic_move"; empty otherwise.
+      hypothesis: one-line human-readable prediction of what the branch does.
+      protected_qualities: dimension names the producer promises not to regress.
+      affected_scope: {track_indices, device_paths, section_ids, clip_slots}.
+      distinctness_reason: why this seed is different from siblings in a set.
+      risk_label: execution safety tier.
+      novelty_label: creative novelty tier — maps to the safe/strong/unexpected UX triptych.
+      analytical_only: true ⇒ no plan will be compiled; branch is directional only.
+    """
+
+    seed_id: str
+    source: BranchSource
+    move_id: str = ""
+    hypothesis: str = ""
+    protected_qualities: list[str] = field(default_factory=list)
+    affected_scope: dict = field(default_factory=dict)
+    distinctness_reason: str = ""
+    risk_label: RiskLabel = "low"
+    novelty_label: NoveltyLabel = "strong"
+    analytical_only: bool = False
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class CompiledBranch:
+    """Post-compilation branch — supersedes the move_id-locked ExperimentBranch.
+
+    Fields:
+      branch_id: stable identifier scoped to a branch set.
+      seed: the originating BranchSeed (carries source, hypothesis, move_id).
+      compiled_plan: execution-router-ready plan dict, or None for analytical-only.
+      execution_log: per-step results after run/commit; [{tool, backend, ok, error, result}].
+      before_snapshot / after_snapshot: captured session state dicts.
+      evaluation: evaluator result dict; shape determined by the evaluator.
+      score: composite quality score (0-1).
+      status: pending | running | evaluated | committed | discarded
+              | interesting_but_failed   ← PR7 will gate on this
+      created_at_ms / executed_at_ms: timestamps.
+    """
+
+    branch_id: str
+    seed: BranchSeed
+    compiled_plan: Optional[dict] = None
+    execution_log: list = field(default_factory=list)
+    before_snapshot: Optional[dict] = None
+    after_snapshot: Optional[dict] = None
+    evaluation: Optional[dict] = None
+    score: float = 0.0
+    status: str = "pending"
+    created_at_ms: int = 0
+    executed_at_ms: int = 0
+
+    @property
+    def move_id(self) -> str:
+        """Back-compat convenience — delegates to seed.move_id.
+
+        Lets callers that currently read branch.move_id keep working once
+        ExperimentBranch migrates to wrap CompiledBranch.
+        """
+        return self.seed.move_id
+
+    @property
+    def analytical_only(self) -> bool:
+        """A branch is analytical when the seed says so OR when no plan exists."""
+        return self.seed.analytical_only or self.compiled_plan is None
+
+    def to_dict(self) -> dict:
+        d = {
+            "branch_id": self.branch_id,
+            "seed": self.seed.to_dict(),
+            "move_id": self.move_id,
+            "score": self.score,
+            "status": self.status,
+            "analytical_only": self.analytical_only,
+            "created_at_ms": self.created_at_ms,
+        }
+        if self.compiled_plan:
+            d["step_count"] = self.compiled_plan.get("step_count", 0)
+            d["summary"] = self.compiled_plan.get("summary", "")
+        if self.before_snapshot is not None:
+            d["before_snapshot"] = self.before_snapshot
+        if self.after_snapshot is not None:
+            d["after_snapshot"] = self.after_snapshot
+        if self.evaluation is not None:
+            d["evaluation"] = self.evaluation
+        if self.execution_log:
+            d["execution_log"] = self.execution_log
+            d["steps_ok"] = sum(1 for e in self.execution_log if e.get("ok"))
+            d["steps_failed"] = sum(1 for e in self.execution_log if not e.get("ok"))
+        return d
+
+
+# ── Factory helpers ──────────────────────────────────────────────────────
+
+def _stable_seed_id(prefix: str, *parts: str) -> str:
+    """Deterministic seed_id from parts — no timestamps, stable across runs."""
+    seed = "|".join(str(p) for p in parts)
+    return f"{prefix}_" + hashlib.sha256(seed.encode()).hexdigest()[:10]
+
+
+def seed_from_move_id(
+    move_id: str,
+    seed_id: str = "",
+    hypothesis: str = "",
+    novelty_label: NoveltyLabel = "strong",
+    risk_label: RiskLabel = "low",
+    protected_qualities: Optional[list[str]] = None,
+    distinctness_reason: str = "",
+) -> BranchSeed:
+    """Build a semantic_move seed — the baseline producer path.
+
+    Mirrors how wonder_mode.engine.discover_moves already hands moves to
+    build_variant. In later PRs, the Wonder distinctness selector will emit
+    BranchSeed directly instead of move dicts.
+    """
+    if not seed_id:
+        seed_id = _stable_seed_id("seed", "move", move_id, novelty_label)
+    return BranchSeed(
+        seed_id=seed_id,
+        source="semantic_move",
+        move_id=move_id,
+        hypothesis=hypothesis or f"Apply {move_id}",
+        novelty_label=novelty_label,
+        risk_label=risk_label,
+        protected_qualities=protected_qualities or [],
+        distinctness_reason=distinctness_reason,
+    )
+
+
+def freeform_seed(
+    seed_id: str,
+    hypothesis: str,
+    affected_scope: Optional[dict] = None,
+    protected_qualities: Optional[list[str]] = None,
+    distinctness_reason: str = "",
+    novelty_label: NoveltyLabel = "strong",
+    risk_label: RiskLabel = "medium",
+    source: BranchSource = "freeform",
+) -> BranchSeed:
+    """Build a freeform seed — producer has a concrete hypothesis without a move.
+
+    The compiled plan is attached downstream by the producer; this seed
+    carries intent only. Used by synthesis_brain, composer, and any
+    producer that doesn't go through semantic_moves.compiler.
+    """
+    return BranchSeed(
+        seed_id=seed_id,
+        source=source,
+        hypothesis=hypothesis,
+        affected_scope=affected_scope or {},
+        protected_qualities=protected_qualities or [],
+        distinctness_reason=distinctness_reason,
+        novelty_label=novelty_label,
+        risk_label=risk_label,
+    )
+
+
+def analytical_seed(
+    seed_id: str,
+    hypothesis: str,
+    source: BranchSource = "freeform",
+    protected_qualities: Optional[list[str]] = None,
+) -> BranchSeed:
+    """Build an analytical-only seed — no plan will be compiled.
+
+    Used when a producer has a directional suggestion but no executable path:
+    - Wonder fallback when no move matches (already present as
+      build_analytical_variant in wonder_mode.engine).
+    - Synthesis brain on opaque devices where parameter state can be read
+      but safe mutations cannot be proposed yet.
+    """
+    return BranchSeed(
+        seed_id=seed_id,
+        source=source,
+        hypothesis=hypothesis,
+        protected_qualities=protected_qualities or [],
+        analytical_only=True,
+    )

package/mcp_server/composer/__init__.py

@@ -1 +1,10 @@
-"""Composer Engine — auto-composition from text prompts via Splice + Sample Engine."""
+"""Composer Engine — auto-composition from text prompts via Splice + Sample Engine.
+
+PR11 adds branch_producer.propose_composer_branches() for emitting
+multiple section-hypothesis BranchSeeds alongside the existing
+single-plan compose() entry point.
+"""
+
+from .branch_producer import propose_composer_branches
+
+__all__ = ["propose_composer_branches"]

package/mcp_server/composer/branch_producer.py

@@ -0,0 +1,229 @@
+"""Composer branch producer — emit section-hypothesis BranchSeeds.
+
+PR11 adds a branch-native entry point alongside the existing compose()
+pipeline. Instead of a single deterministic layer plan, callers can
+request N distinct compositional hypotheses and audition them via
+create_experiment(seeds=..., compiled_plans=...).
+
+Design:
+  A composer branch is a CompositionIntent + variant_strategy. Three
+  canned strategies are shipped in PR11:
+
+    "canonical"     — intent unchanged, layer plan uses genre defaults
+    "energy_shift"  — intent.energy inverted around 0.5 (dense ⇄ sparse)
+    "layer_contrast" — one role swapped in the layer plan (e.g. bass
+                       role replaced with pad-anchor, or percussion
+                       stripped to emphasize melodic content)
+
+Seeds carry source="composer". Each branch produces a pre-compiled
+plan through the existing ComposerEngine.compose() pipeline so
+run_experiment respects the plans without re-compiling. Later PRs
+can add more strategies (key-shift, section-reorder, tempo-halftime).
+"""
+
+from __future__ import annotations
+
+import hashlib
+from typing import Optional
+
+from ..branches import BranchSeed, freeform_seed
+from .prompt_parser import parse_prompt, CompositionIntent
+from .layer_planner import plan_layers, plan_sections
+
+
+# Strategy registry — each function takes an intent and returns (modified
+# intent, distinctness_reason, novelty_label, risk_label).
+def _strategy_canonical(intent: CompositionIntent):
+    return (
+        intent,
+        "baseline composition with genre defaults",
+        "safe",
+        "low",
+    )
+
+
+def _strategy_energy_shift(intent: CompositionIntent):
+    new = CompositionIntent(
+        genre=intent.genre,
+        sub_genre=intent.sub_genre,
+        mood=intent.mood,
+        tempo=intent.tempo,
+        key=intent.key,
+        descriptors=list(intent.descriptors),
+        explicit_elements=list(intent.explicit_elements),
+        energy=round(1.0 - intent.energy, 2),
+        layer_count=intent.layer_count,
+        duration_bars=intent.duration_bars,
+    )
+    direction = "denser" if new.energy > intent.energy else "sparser"
+    return (
+        new,
+        f"energy shifted from {intent.energy:.1f} → {new.energy:.1f} ({direction})",
+        "strong",
+        "low",
+    )
+
+
+def _strategy_layer_contrast(intent: CompositionIntent):
+    new = CompositionIntent(
+        genre=intent.genre,
+        sub_genre=intent.sub_genre,
+        mood=intent.mood,
+        tempo=intent.tempo,
+        key=intent.key,
+        descriptors=list(intent.descriptors),
+        # Force the layer planner to drop "bass" as an anchor role by adding
+        # "pad" explicitly to explicit_elements and not asking for a bass.
+        explicit_elements=list(intent.explicit_elements) + ["pad_anchor", "no_bass"],
+        energy=intent.energy,
+        layer_count=intent.layer_count,
+        duration_bars=intent.duration_bars,
+    )
+    return (
+        new,
+        "layer contrast — pad anchor instead of bass line",
+        "unexpected",
+        "medium",
+    )
+
+
+_STRATEGIES = [
+    ("canonical", _strategy_canonical),
+    ("energy_shift", _strategy_energy_shift),
+    ("layer_contrast", _strategy_layer_contrast),
+]
+
+
+def _short_id(prefix: str, key: str) -> str:
+    h = hashlib.sha256(f"{prefix}:{key}".encode()).hexdigest()[:10]
+    return f"{prefix}_{h}"
+
+
+def propose_composer_branches(
+    request_text: str,
+    kernel: Optional[dict] = None,
+    count: int = 2,
+    search_roots: Optional[list] = None,
+) -> list[tuple[BranchSeed, dict]]:
+    """Emit composer-source branch seeds with pre-compiled plans.
+
+    request_text: the natural-language composition prompt.
+    kernel: optional SessionKernel dict — reads ``freshness`` to gate
+      whether high-novelty strategies (layer_contrast) are included.
+    count: desired number of branches (clamped to 1..len(_STRATEGIES)).
+    search_roots: optional list of directory paths for sample resolution,
+      threaded to ComposerEngine.compose().
+
+    Returns a list of (BranchSeed, compiled_plan_dict) tuples. Each plan
+    is a dict with {"steps": [...], "step_count": N, "summary": "..."}
+    compatible with run_experiment.
+    """
+    kernel = kernel or {}
+    freshness = float(kernel.get("freshness", 0.5) or 0.5)
+
+    intent = parse_prompt(request_text)
+
+    # Gate high-novelty strategies on freshness.
+    if freshness < 0.4:
+        strategies = [_STRATEGIES[0]]  # canonical only
+    elif freshness < 0.7:
+        strategies = _STRATEGIES[:2]   # canonical + energy_shift
+    else:
+        strategies = _STRATEGIES       # all three
+
+    count = max(1, min(count, len(strategies)))
+    results: list[tuple[BranchSeed, dict]] = []
+
+    for name, strategy_fn in strategies[:count]:
+        try:
+            variant_intent, reason, novelty, risk = strategy_fn(intent)
+            plan = _build_section_hypothesis_plan(variant_intent, name)
+
+            seed = freeform_seed(
+                seed_id=_short_id(f"cmp_{name}", request_text),
+                hypothesis=f"Composer branch ({name}): {reason}",
+                source="composer",
+                novelty_label=novelty,
+                risk_label=risk,
+                distinctness_reason=reason,
+            )
+            results.append((seed, plan))
+        except Exception as exc:
+            # Don't let one strategy's failure kill the rest.
+            import logging
+            logging.getLogger(__name__).warning(
+                "composer strategy %s failed: %s", name, exc
+            )
+            continue
+
+    return results
+
+
+def _build_section_hypothesis_plan(intent: CompositionIntent, strategy_name: str) -> dict:
+    """Build a lightweight, executable plan from an intent.
+
+    Uses the synchronous planning primitives (plan_layers, plan_sections)
+    to generate a scaffolding plan: set_tempo + create_midi_track per layer
+    with sensible names and colors. Sample resolution is deferred —
+    callers that want samples loaded should either hand the branch to
+    commit_experiment after auditioning, or re-run ComposerEngine.compose()
+    on the winning intent.
+
+    Returns a dict with {"steps", "step_count", "summary"}.
+    """
+    layers = plan_layers(intent)
+    sections = plan_sections(intent)
+
+    steps: list[dict] = []
+
+    # Step 1: tempo — only when intent.tempo is set. Remote transport
+    # handler takes "tempo" (not "bpm") — see transport.py:set_tempo.
+    if intent.tempo and intent.tempo > 0:
+        steps.append({
+            "tool": "set_tempo",
+            "params": {"tempo": float(intent.tempo)},
+        })
+
+    # Step 2: one create_midi_track per layer role — the skeleton every
+    # subsequent composition step builds on.
+    for idx, layer in enumerate(layers):
+        name = getattr(layer, "role", f"layer_{idx}")
+        steps.append({
+            "tool": "create_midi_track",
+            "params": {"name": str(name)},
+        })
+
+    # Step 3: one create_scene + set_scene_name per section. Remote
+    # create_scene handler only accepts "index" — see scenes.py:create_scene.
+    # Section labels land via set_scene_name after creation. step_id +
+    # $from_step binding resolves the new scene index so parallel branches
+    # with different section counts don't step on each other.
+    for s_idx, section in enumerate(sections):
+        if isinstance(section, dict):
+            sec_name = section.get("name", f"Section {s_idx + 1}")
+        else:
+            sec_name = f"Section {s_idx + 1}"
+        create_step_id = f"create_scene_{s_idx}"
+        steps.append({
+            "tool": "create_scene",
+            "step_id": create_step_id,
+            "params": {"index": -1},  # -1 ⇒ append at end
+        })
+        steps.append({
+            "tool": "set_scene_name",
+            "params": {
+                "scene_index": {"$from_step": create_step_id, "path": "index"},
+                "name": str(sec_name),
+            },
+        })
+
+    summary = (
+        f"{strategy_name}: {intent.genre or 'auto-genre'} @ "
+        f"{intent.tempo or 'auto-tempo'} bpm, energy {intent.energy:.1f} — "
+        f"{len(layers)} layers, {len(sections)} sections"
+    )
+    return {
+        "steps": steps,
+        "step_count": len(steps),
+        "summary": summary,
+    }