livepilot 1.26.1 → 1.26.2

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## v1.26.2 — 2026-05-27
+
+Patch release for Claude/Codex plugin instruction correctness and local install reliability.
+
+### Fixed
+
+- Claude/Codex plugin commands now use `ensure_analyzer_on_master` instead of direct master-track analyzer loading, preserving the invariant that `LivePilot_Analyzer` measures the final post-master-chain signal.
+- `/beat` now builds the master processing chain before ensuring the analyzer, preventing pre-effect spectral/RMS reads in fresh sessions.
+- V2 semantic-move guidance now matches runtime behavior: `apply_semantic_move(mode="improve")` compiles an approval-ready plan and does not execute until the returned steps are run.
+- Plugin device-loading guidance now routes through the Device Atlas first, then exact browser URI loading, with `find_and_load_device` reserved for simple built-in effects.
+- Release checklist stale claims were corrected: removed the obsolete non-analyzer subtotal and updated the domain-list reminder from 45 to 56 domains.
+- Producer-agent capability guidance now distinguishes stale/intermittent analyzer data (`measured_degraded`) from analyzer absence (`judgment_only`).
+
+### Tests
+
+- Added `tests/test_plugin_instruction_contracts.py` to prevent regressions in analyzer preflight guidance, semantic-move approval semantics, release-count claims, and core-skill enriched-device metadata coverage.
+
 ## v1.26.1 — 2026-05-24
 
 Patch release for installer/release hygiene and live execution correctness.

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

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.26.1",
+  "version": "1.26.2",
   "description": "Agentic production system for Ableton Live 12 \u2014 465 tools, 56 domains, 44 semantic moves, device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, 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.26.1",
+  "version": "1.26.2",
   "description": "Agentic production system for Ableton Live 12 \u2014 465 tools, 56 domains, 44 semantic moves, device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
   "author": {
     "name": "Pilot Studio"

package/livepilot/agents/livepilot-producer/AGENT.md

@@ -206,7 +206,7 @@ After loading any instrument:
 ### Critical device loading rules:
 
 - **NEVER load bare "Drum Rack"** — it's empty. Load a **kit preset**: `search_browser` path="Drums" name_filter="Kit" → `load_browser_item`
-- **For synths, use `search_browser` → `load_browser_item`** with exact URI
+- **For synths, consult `atlas_search` or `atlas_suggest` first, then use `search_browser` → `load_browser_item`** with exact URI
 - **After loading any effect**, set key parameters to non-default values
 
 ## V2 Engine Intelligence
@@ -241,7 +241,7 @@ This replaces ad-hoc `get_session_info` + `get_track_info` calls for complex tas
 
 Call `get_capability_state` to know what's trustworthy right now:
 - `normal`: full analyzer + evaluation loop available
-- `measured_degraded`: no analyzer — defer to musical judgment for keep/undo
+- `measured_degraded`: analyzer data is stale or intermittent — refresh playback/cache before trusting spectral comparisons
 - `judgment_only`: minimal evidence — be conservative
 - `read_only`: can inspect but not mutate
 

package/livepilot/commands/beat.md

@@ -11,8 +11,8 @@ If the user asks for a **fresh start** (new track, clean slate, start from scrat
 
 1. **Read the session** — `get_session_info` to see what exists
 2. **Delete all existing tracks** — loop through all tracks with `delete_track`, starting from the highest index down to 0 (deleting from the top prevents index shifts)
-3. **Load the M4L Analyzer on master** — `find_and_load_device(track_index=-1000, device_name="LivePilot_Analyzer")`. This enables real-time spectral analysis, RMS metering, and key detection for the entire session. If it fails, try `search_browser(path="max_for_live", name_filter="LivePilot")` to find the URI and load manually.
-4. **Set up master chain** — load Glue Compressor + EQ Eight + Utility on master for bus processing
+3. **Set up master chain** — load Glue Compressor + EQ Eight + Utility on master for bus processing
+4. **Ensure analyzer last** — call `ensure_analyzer_on_master`. This enables real-time spectral analysis, RMS metering, and key detection, and prevents the analyzer from measuring pre-master-chain audio. If it returns `install_required`, call `install_m4l_device(source_path="<repo>/m4l_device/LivePilot_Analyzer.amxd")` and retry. If it warns that the analyzer is not last on master, tell the user and do not trust spectral reads until it is moved after all effects.
 5. **Verify analyzer** — wait 2 seconds, then call `get_master_spectrum`. If it returns data, the bridge is connected. If it errors with "UDP bridge not connected", call `reconnect_bridge` to rebind.
 
 If the user is adding to an **existing project**, skip step 0 — just call `get_session_info` and work with what's there.
@@ -24,7 +24,7 @@ Genre, tempo range, mood, reference tracks.
 `set_tempo`, create tracks for drums/bass/harmony/melody with `create_midi_track`, name and color them.
 
 ## Step 3: Load instruments
-Use `search_browser` to find devices by name, `load_browser_item` or `find_and_load_device` to load them.
+Consult `atlas_search` or `atlas_suggest` first, then use `search_browser` to resolve the exact URI and `load_browser_item` to load it. Use `find_and_load_device` only for simple built-in effects named in the livepilot-core exception list.
 
 ## Step 4: Verify device health
 After loading, run `get_device_info` on each loaded device. A `parameter_count` of 0 or 1 on AU/VST plugins means the plugin failed to initialize (dead plugin). If detected:

package/livepilot/commands/evaluate.md

@@ -12,7 +12,9 @@ Run the universal evaluation loop on recent production changes.
    - `read_only` — session disconnected
 
 2. **Ensure analyzer** — if mode is `judgment_only`, try to get full perception:
-   - `find_and_load_device(track_index=-1000, device_name="LivePilot_Analyzer")`
+   - `ensure_analyzer_on_master`
+   - If it returns `install_required`, call `install_m4l_device(source_path="<repo>/m4l_device/LivePilot_Analyzer.amxd")` and retry
+   - If it warns that the analyzer is not last on master, report that spectral evidence is untrusted until repaired
    - Wait 2s, then `get_master_spectrum` to test the bridge
    - If bridge disconnected: `reconnect_bridge`
    - If still unavailable: proceed with `judgment_only` but tell the user

package/livepilot/commands/mix.md

@@ -9,7 +9,7 @@ Help the user mix their session using the V2 orchestration pipeline.
 
 1. **Session kernel** — `get_session_kernel(request_text=<user's request>, mode="improve")` for the full turn snapshot
 2. **Route** — `route_request(<user's request>)` to get engine routes + semantic move recommendations
-3. **Ensure analyzer** — if `get_master_spectrum` errors, load it: `find_and_load_device(track_index=-1000, device_name="LivePilot_Analyzer")`. If bridge disconnected, try `reconnect_bridge`.
+3. **Ensure analyzer** — call `ensure_analyzer_on_master` before trusting spectral reads. If it returns `install_required`, call `install_m4l_device(source_path="<repo>/m4l_device/LivePilot_Analyzer.amxd")` and retry. If it warns that the analyzer is not last on master, tell the user and treat spectral data as untrusted until it is repaired. If the bridge is disconnected, try `reconnect_bridge`.
 
 ## Analysis Phase
 
@@ -29,7 +29,7 @@ Help the user mix their session using the V2 orchestration pipeline.
 
 ## Execution Phase
 
-11. **Apply with approval** — `apply_semantic_move(move_id, mode="improve")` returns the compiled plan. Present it to the user: "I'd suggest: push Drums to 0.75, pull Pad to 0.25. Shall I do it?"
+11. **Compile for approval** — `apply_semantic_move(move_id, mode="improve")` returns the compiled plan without executing it. Present the concrete steps to the user. After approval, execute the returned steps individually and verify each write.
 12. **Verify after EVERY change** — read `value_string` in response, call `get_track_meters(include_stereo=true)`, check no track went silent
 13. **Capture + analyze** — `capture_audio` then `analyze_loudness` for LUFS/LRA, `analyze_spectrum_offline` for centroid/balance
 14. **Evaluate** — `evaluate_mix_move` with before/after snapshots. If `keep_change` is false, `undo` immediately.

package/livepilot/commands/sounddesign.md

@@ -13,7 +13,7 @@ Guide the user through designing a sound using the V2 orchestration pipeline.
 ## Design Phase
 
 3. **Ask about target** — what character? (warm pad, aggressive bass, shimmering lead, etc.)
-4. **Choose instrument** — `search_browser` to find devices, `load_browser_item` to load
+4. **Choose instrument** — consult `atlas_search` or `atlas_suggest` for candidate devices, then use `search_browser` to resolve the exact URI and `load_browser_item` to load
 5. **Verify health** — `get_device_info` to confirm plugin initialized. Read `value_string` from `get_device_parameters` to understand actual units.
 6. **Shape sound** — `set_device_parameter` or `batch_set_parameters`. **ALWAYS read `value_string` in response** to confirm Hz/dB/% values make sense.
 7. **Verify after every change** — `get_track_meters(include_stereo=true)` — if stereo drops to 0, the effect killed the signal.
@@ -26,7 +26,7 @@ Guide the user through designing a sound using the V2 orchestration pipeline.
 
 ## Effects & Automation
 
-11. **Add effects** — load with `find_and_load_device(track_index, device_name)`. Verify health.
+11. **Add effects** — consult the atlas or relevant device-knowledge reference first. Load exact browser URIs with `load_browser_item`, or use `find_and_load_device` only for simple built-in effects named in the livepilot-core exception list. Verify health.
 12. **Organic movement** — `apply_automation_shape(curve_type="perlin")` for filter/send drift
 13. **Automation recipes** — `apply_automation_recipe` for breathing, vinyl_crackle, auto_pan. Verify after applying.
 

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

@@ -7,7 +7,7 @@ description: Core discipline for LivePilot — agentic production system for Abl
 
 Agentic production system for Ableton Live 12. 465 tools across 56 domains, three layers:
 
-- **Device Atlas** — 5264 devices indexed (135 enriched with sonic intelligence, 683 drum kits). Consult `atlas_search` or `atlas_suggest` before loading any device. Never guess a device name.
+- **Device Atlas** — 5264 devices indexed (120 enriched with sonic intelligence, 683 drum kits). Consult `atlas_search` or `atlas_suggest` before loading any device. Never guess a device name.
 - **M4L Analyzer** — Real-time audio analysis on the master bus (9-band spectrum sub_low → air, RMS/peak, key detection). Optional — all core tools work without it.
 - **Technique Memory** — Persistent storage for production decisions. Consult `memory_recall` before creative tasks to understand user taste.
 
@@ -18,7 +18,7 @@ Agentic production system for Ableton Live 12. 465 tools across 56 domains, thre
 3. **Use `undo` liberally** — mention it to users when doing destructive ops
 4. **One operation at a time** — verify between steps
 5. **Track indices are 0-based** — negative for return tracks (-1=A, -2=B), -1000 for master
-6. **NEVER invent device/preset names** — always `search_browser` first, use exact `uri` from results. Exception: `find_and_load_device` for built-in effects only ("Reverb", "Delay", "Compressor", "EQ Eight", "Saturator", "Utility")
+6. **NEVER invent device/preset names** — consult `atlas_search` or `atlas_suggest` first, then use `search_browser` and load the exact `uri` from results. Exception: `find_and_load_device` for built-in effects only ("Reverb", "Delay", "Compressor", "EQ Eight", "Saturator", "Utility")
 7. **Color indices 0-69** — Ableton's fixed palette
 8. **Volume 0.0-1.0, pan -1.0 to 1.0** — normalized, not dB
 9. **Tempo range 20-999 BPM**
@@ -76,7 +76,7 @@ Report ALL errors to the user immediately. Common failure modes:
 - **M4L bridge timeout** — device may be busy or removed → retry or skip analyzer features
 - **Connection timeout** — Ableton unresponsive → check if session is heavy
 - **Volume reset on scene fire** — Ableton restores mixer state when firing scenes. Always re-apply `set_track_volume`/`set_track_pan` after `fire_scene` if your mix settings differ from what was stored in the clips
-- **M4L Analyzer not connected** — if `get_master_spectrum` errors with "Analyzer not detected", auto-load it: `find_and_load_device(track_index=-1000, device_name="LivePilot_Analyzer")`. If it errors with "UDP bridge not connected", try `reconnect_bridge` first
+- **M4L Analyzer not connected** — if `get_master_spectrum` errors with "Analyzer not detected", call `ensure_analyzer_on_master`. If it returns `install_required`, call `install_m4l_device(source_path="<repo>/m4l_device/LivePilot_Analyzer.amxd")` and retry. If it errors with "UDP bridge not connected", try `reconnect_bridge` first
 - **Another client connected** — Remote Script only accepts one TCP client on port 9878. If you see this error, the MCP server is already connected. Use MCP tools instead of raw TCP
 
 ## Technique Memory
@@ -176,8 +176,8 @@ Use when the user has a concrete, specific request ("tighten the low end", "make
 2. **`get_session_kernel`** — build the unified turn snapshot
 3. **`propose_next_best_move`** — get ranked semantic move suggestions (taste-aware)
 4. **`preview_semantic_move`** — see what a move will do before committing
-5. **`apply_semantic_move`** — compile and execute the move
-6. **Evaluate** — use the appropriate evaluator to check the result
+5. **`apply_semantic_move(mode="improve")`** — compile the move and return the concrete plan for approval; after approval, execute the returned steps individually
+6. **Evaluate** — use the appropriate evaluator after the approved steps actually run
 
 ### Flow B — Exploratory (branch-native, for creative search)
 Use when the user wants options, variants, or is stuck ("surprise me", "try some things", "I don't know what I want", "make it more like X"). **Flow B is also correct when `route_request` returns `workflow_mode="creative_search"`.**
@@ -198,7 +198,7 @@ Use when the user wants options, variants, or is stuck ("surprise me", "try some
 **Rule of thumb**: if the user asked for a specific fix, Flow A. If they asked "what would you do?" or mentioned feel/vibe without parameters, Flow B.
 
 ### Semantic Moves
-High-level musical intents that compile to deterministic tool sequences. 7 families (44 moves as of v1.26.1):
+High-level musical intents that compile to deterministic tool sequences. 7 families (44 moves as of v1.26.2):
 - **mix** — `tighten_low_end`, `widen_stereo`, `make_punchier`, `darken_without_losing_width`, `reduce_repetition_fatigue`, `make_kick_bass_lock`, `reduce_foreground_competition`
 - **arrangement** — `refresh_repeated_section`, plus structural moves defined alongside mix
 - **transition** — `create_buildup_tension`, `smooth_scene_handoff`, `increase_contrast_before_payoff`, `bridge_sections`, `increase_forward_motion`, `open_chorus`, `create_breakdown`

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

@@ -1,4 +1,4 @@
-# LivePilot v1.26.1 — Architecture & Tool Reference
+# LivePilot v1.26.2 — Architecture & Tool Reference
 
 Agentic production system for Ableton Live 12. 465 tools across 56 domains. Device atlas (5264 devices, 120 enriched, 47 with aesthetic-tagged `signature_techniques`), spectral perception (M4L analyzer with 9-band FFT — sub_low / sub / low / low_mid / mid / high_mid / high / presence / air), 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, **LIVE Splice describe-a-sound + variations via captured GraphQL endpoints (v1.17)**, drum-rack pad-by-pad construction, live dead-device detection via meter sampling, role-aware Simpler defaults, session-record arrangement-automation workaround.
 

package/livepilot/skills/livepilot-creative-director/SKILL.md

@@ -107,6 +107,12 @@ this skill. No → divergence path.
 
 When triggered, these phases are REQUIRED in order. Skip none.
 
+## Character-First Bias
+
+For open-ended quality requests, treat timbre and spectral character as the main creative surface. Do not let the `mix` family win just because words like punch, clean, warm, dark, bright, or wide could be solved by volume/pan/send changes. Prefer `sound_design`, `device_creation`, `sample`, `arrangement`, or `transition` when analyzer evidence suggests a source, instrument, parameter, modulation, envelope, or structural decision would create more musical value.
+
+The `mix` family is dominant only when the user asks for balance, loudness, headroom, masking, stereo translation, send levels, or an explicit mix pass. Otherwise use mix analysis as safety/evidence and keep it out of the main creative slot.
+
 ### Phase 1 — Ground
 
 Read in parallel (all are fast). All of these are REQUIRED, not
@@ -119,6 +125,7 @@ advisory — skipping them is how pattern-repetition survives:
 - `get_action_ledger_summary(limit=10)` — recent committed moves (repeat detection, see `references/anti-repetition-rules.md` for the recency threshold table). **v1.20 correction**: previous docs pointed at `memory_list`, which actually reads the persistent technique library (opt-in `memory_learn` writes) — a DIFFERENT store. The action ledger is the authoritative source; `apply_semantic_move` in explore mode populates it automatically.
 - `get_last_move` — the single most recent committed move; populate the brief's `last_move_target` field so Phase 3 cannot repeat it
 - `get_project_brain_summary` (or `build_project_brain` if absent) — track identity, accepted novelty band
+- Analyzer character read when available: `get_master_spectrum`, `get_spectral_shape`, `get_onsets`, `get_novelty`, and `get_momentary_loudness` for evidence about brightness, flatness, motion, transient shape, and loudness safety. Use these to bias Phase 3 toward instrument/device/parameter decisions, not low-value level tweaks.
 - `explain_song_identity` when the project has one
 - `detect_stuckness` — cheap; its confidence drives escalation decisions (see §Anti-Repetition Protocol below)
 - **Concept packet load (HARD filter when present):** if the user named an artist or genre, or if `project_brain` has a genre identity, retrieve the structured YAML packet from `livepilot-core/references/concepts/artists/<slug>.yaml` or `livepilot-core/references/concepts/genres/<slug>.yaml`. Fall back to the narrative .md entry only if no matching YAML exists. The packet's `avoid` list is a HARD filter on Phase 3 candidates. The packet's `reach_for` lists seed the candidate device pool. The packet's `key_techniques` list resolves to atlas `signature_techniques` or `sample-techniques.md` / `sound-design-deep.md` entries. If NO reference is named and `project_brain` has no genre identity, skip packet loading — do not infer. See `livepilot-core/references/concepts/_schema.md` for the full packet structure and loading rules.

package/livepilot/skills/livepilot-creative-director/references/move-family-diversity-rule.md

@@ -44,7 +44,7 @@ Never invent an eighth family at the director level.
 
 **Discovery:** always call `list_semantic_moves(domain=<family>)` at
 runtime to enumerate — do not hardcode move IDs. Families are stable;
-the move catalog grows. As of v1.26.1 the runtime returns 44 moves
+the move catalog grows. As of v1.26.2 the runtime returns 44 moves
 across all 7 domains.
 
 **Why the director never invents an eighth `rhythmic` family:** the

package/livepilot/skills/livepilot-evaluation/references/capability-modes.md

@@ -173,4 +173,4 @@ routing is transparent.
 - Link Audio (tempo-sync sharing between Live sets) — tracked as a
   future Collaborative-tier feature.
 - Stem Separation v2 — tracked as a future Collaborative-tier feature.
-Neither is available in the 1.26.1 release — still pending.
+Neither is available in the 1.26.2 release — still pending.

package/livepilot/skills/livepilot-mix-engine/SKILL.md

@@ -7,6 +7,14 @@ description: This skill should be used when the user asks to "analyze my mix", "
 
 The mix engine runs an iterative critic loop: analyze, plan, execute, measure, evaluate, keep or undo. Every mix change is measured before and after. Nothing stays unless it scores better than the original.
 
+## Character-First Default
+
+Do not treat the full loop as the default for vague requests like "make it better", "more character", "more alive", "punchier", "warmer", or "more interesting". Those are usually sound-design or creative-direction requests. Start from analyzer character (`sonic_character`, `get_spectral_shape`, `get_novelty`, `get_onsets`, `get_mel_spectrum`) and prefer source, instrument, device-chain, envelope, filter, saturation, modulation, and transient-shape decisions before generic level changes.
+
+Use `set_track_volume`, `set_track_pan`, and broad send-level balancing only when the user explicitly asks for balance/level/pan/send work, or when analyzer evidence shows a safety/translation problem such as clipping, headroom collapse, mono collapse, or a severe masking issue. Producers can adjust simple loudness by ear quickly; LivePilot's value is in hearing spectral character and choosing a smarter musical intervention.
+
+For normal work, cap mix-engine action to one high-value move plus a short verdict. Enter the repeated full loop only for explicit requests like "deep mix pass", "mastering prep", "fix all mix issues", or an exact target such as LUFS/headroom/mono compatibility.
+
 ## The Mix Critic Loop
 
 Follow these steps in order. Do not skip the evaluation step.
@@ -81,7 +89,7 @@ If the move scored above 0.7 and the user confirms satisfaction, call `memory_le
 
 ### Step 9 — Repeat
 
-Return to Step 1 and re-analyze. The critic list updates after each change. Continue until no high-severity issues remain or the user says to stop.
+Return to Step 1 and re-analyze only when the user requested a deep/full mix pass. Otherwise stop after the first measured high-value intervention and report the remaining optional issues as suggestions. Avoid spending a turn on small volume-balancing loops unless they are the requested task.
 
 ## Quick Mix Checks
 

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

@@ -7,6 +7,12 @@ description: This skill should be used when the user asks to "mix", "balance lev
 
 Balance track levels, configure routing, apply mix effects, and analyze frequency content in Ableton Live.
 
+## Default Value Filter
+
+For broad musical requests, do not spend the turn on manual-feeling volume balancing. Levels, pan, and sends are useful when the user asks for them, when clipping/headroom/translation is objectively unsafe, or when a routing architecture is part of the style. Otherwise, treat meters as context and use analyzer character to make higher-value choices: source selection, filter/envelope shape, saturation, modulation, transient design, or a better device/preset.
+
+When a request says "more punch", "more warmth", "more character", "less flat", "more alive", or similar, route through sound-design/creative-director first and use mix tools only as safety checks.
+
 ## Read Before Write
 
 Always understand the current state before changing anything:
@@ -121,7 +127,7 @@ When the LivePilot Analyzer M4L device is on the master track:
 - `get_master_rms` — true RMS and peak levels for loudness assessment
 - `get_detected_key` — detect musical key from audio content
 
-Use spectrum data to make informed EQ decisions. If the low_mid band is 6 dB hotter than everything else, there is mud to clean up. If the air band is absent, the mix may sound dull.
+Use spectrum data to make informed EQ decisions. If the low_mid band is 6 dB hotter than everything else, there is mud to clean up. If the air band is absent, the mix may sound dull. When FluCoMa streams are active, prefer `get_spectral_shape`, `get_mel_spectrum`, `get_onsets`, and `get_novelty` for character decisions; those descriptors tell you whether the sound is bright/dark, flat/peaked, static/moving, or transient/soft in a way simple level meters cannot.
 
 ## Mix Engine — Critic-Driven Analysis
 
@@ -144,11 +150,12 @@ Use the mix engine when the user wants a critical evaluation of their mix, not j
 
 Follow this progression — start fast, go deeper only when needed:
 
-1. **Instant:** `get_master_spectrum` + `get_track_meters` — frequency balance + levels. Answers 80% of mix questions.
-2. **Fast (1-5s):** `analyze_loudness` + `analyze_mix` — LUFS, true peak, and full mix analysis. For mastering prep.
-3. **Slow (5-15s):** `compare_to_reference` + `analyze_spectrum_offline` — reference matching, offline spectral analysis. Ask the user first.
+1. **Instant:** `get_master_spectrum` + `get_track_meters` — frequency balance + safety context.
+2. **Fast character:** `get_spectral_shape` + `get_novelty` + `get_onsets` when available — decide whether the next move belongs to sound design, arrangement, or mix.
+3. **Fast mix (1-5s):** `analyze_loudness` + `analyze_mix` — LUFS, true peak, and full mix analysis. For mastering prep or explicit mix critique.
+4. **Slow (5-15s):** `compare_to_reference` + `analyze_spectrum_offline` — reference matching, offline spectral analysis. Ask the user first.
 
-Never skip levels. Start at the lowest appropriate level and offer to go deeper.
+Never skip safety context. Do not let safety context become a long volume-tweaking session unless the user asked for that.
 
 ## Reference
 

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

@@ -29,7 +29,7 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 ## 2. Tool Count (must ALL match)
 
 Current: **465 tools across 56 domains**.
-Spectral/analyzer (bridge-only): **38**. All others: **292** (work without bridge, some with graceful fallbacks). Backed by 32 bridge commands.
+Spectral/analyzer (bridge-only): **38**. The remaining tool surface works without the bridge or degrades gracefully. Backed by 32 bridge commands.
 
 Verify: `grep -rc "@mcp.tool" mcp_server/tools/ | grep -v ":0" | awk -F: '{sum+=$2} END{print sum}'`
 
@@ -64,7 +64,7 @@ Files that reference tool count:
 Current: **56 domains**: transport, tracks, clips, notes, devices, scenes, mixing, browser, arrangement, memory, analyzer, automation, theory, generative, harmony, midi_io, perception, agent_os, composition, motif, research, planner, project_brain, runtime, evaluation, mix_engine, sound_design, transition_engine, reference_engine, translation_engine, performance_engine, song_brain, preview_studio, hook_hunter, stuckness_detector, wonder_mode, session_continuity, creative_constraints, device_forge, sample_engine, atlas, composer, experiment, musical_intelligence, semantic_moves, diagnostics, follow_actions, grooves, scales, take_lanes, miditool, synthesis_brain, creative_director, user_corpus, audit, grader.
 
 - [ ] All files that mention domain count say "56 domains"
-- [ ] Domain lists include ALL 45 (especially newer domains — they're the most often omitted)
+- [ ] Domain lists include ALL 56 (especially newer domains — they're the most often omitted)
 
 ## 4. npm Registry
 

package/livepilot/skills/livepilot-sound-design-engine/SKILL.md

@@ -7,6 +7,28 @@ description: This skill should be used when the user asks to "design a sound", "
 
 The sound design engine analyzes synth patches, identifies timbral weaknesses, and iteratively refines them through a measured critic loop. Every change is evaluated against the before state.
 
+## Analyzer Character Is the Main Signal
+
+For broad quality requests, this skill is the primary route. "More punch", "warmer", "darker", "brighter", "less flat", "more alive", "more texture", and "more character" should become source/device/parameter decisions before they become volume moves.
+
+When the analyzer is available, read character, not just level:
+
+- `get_master_spectrum` for the 9-band contour
+- `get_spectral_shape` for centroid, flatness, crest, rolloff, and brightness/noise shape
+- `get_mel_spectrum` when EQ or source choice needs perceptual detail
+- `get_onsets` for transient/envelope decisions
+- `get_novelty` for movement/staticness decisions
+- `get_momentary_loudness` only for safety/headroom/loudness context
+
+Translate those measurements into musical moves:
+
+- Bright/harsh character → filter contour, softer source, de-harshing, saturation tone; do not merely lower volume.
+- Dark/dull character → oscillator/filter opening, excitation, air-band source, tasteful saturation; do not merely raise volume.
+- Static/low novelty → modulation, envelope drift, LFO, generative device, granular/vector source.
+- Weak punch → envelope/transient shaping, source layering, attack/release work; volume push is last.
+- Flat/noisy spectrum → source substitution, subtractive filtering, simpler spectral role.
+- Weak weight → instrument/register/source decision before master or track gain.
+
 ## Atlas-first reflex (v1.23.x+, MANDATORY before any creative move)
 
 Before producing ANY creative response, query the user's atlas overlays. The corpus contains 337 entries across 3 namespaces, plus 3,917 parameter-level JSON sidecars — far richer than anything inferable from training data alone.
@@ -97,7 +119,7 @@ Move vocabulary:
 ### Step 4 — Capture Before
 
 1. Call `get_device_parameters(track_index, device_index)` — save current parameter state
-2. Call `get_master_spectrum` — save spectral snapshot (if analyzer available)
+2. Call `get_master_spectrum` plus the relevant character streams above — save spectral snapshot (if analyzer available)
 
 ### Step 5 — Execute
 
@@ -116,7 +138,7 @@ Execute one move at a time. Verify before continuing.
 Repeat the same measurements:
 
 1. Call `get_device_parameters(track_index, device_index)` — confirm the change took effect
-2. Call `get_master_spectrum` — save post-change spectral snapshot
+2. Call `get_master_spectrum` plus the same character streams used before — save post-change spectral snapshot
 
 ### Step 7 — Evaluate
 
@@ -135,7 +157,7 @@ If `keep_change` is `true`, report the improvement. If score > 0.7, consider cal
 
 ### Step 9 — Repeat
 
-Return to Step 2. Re-analyze after each kept change. The critic list updates as issues are resolved. Continue until the user is satisfied or no high-severity issues remain.
+Return to Step 2 only when the user asked for a deep refinement pass. In normal mode, stop after one meaningful character-improving move and summarize what changed plus the next optional direction. Avoid long loops of small parameter nudges.
 
 ## Working with Opaque Plugins
 

package/m4l_device/livepilot_bridge.js

@@ -34,7 +34,7 @@ outlets = 2; // 0: to udpsend (responses), 1: to buffer~/status
 // Single source of truth for the bridge version — bumped alongside the
 // rest of the release manifest. Surfaced in the UI via messnamed("livepilot_version", ...)
 // so the frozen .amxd visibly reports which build it was last exported from.
-var VERSION = "1.26.1";
+var VERSION = "1.26.2";
 
 // ── State ──────────────────────────────────────────────────────────────────
 

package/mcp_server/__init__.py

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

package/mcp_server/composer/full/brief_builder.py

@@ -47,6 +47,15 @@ _DESIGN_TARGETS = (
     "moves to schedule at chosen phrase boundaries. For niche style references "
     "in research_hooks, run WebSearch to ground your form choices in the "
     "actual conventions of that subgenre.\n\n"
+    "CHARACTER-FIRST NORMAL MODE:\n"
+    "Do not spend full mode on long level-balancing loops. Producers can adjust "
+    "simple volume by ear; your high-value job is to choose instruments, sources, "
+    "device chains, macro states, envelopes, filters, saturation, modulation, "
+    "and structural reveals that fit the requested character. Use analyzer/mix "
+    "feedback as evidence and safety, but prefer timbral/source decisions over "
+    "`set_track_volume`, `set_track_pan`, or broad send tweaking unless the "
+    "brief explicitly asks for mix balance, loudness, headroom, stereo translation, "
+    "or masking repair.\n\n"
     "INSTRUMENT SELECTION (v1.25 hybrid knowledge surface — MANDATED FOUR-SOURCE SEARCH):\n"
     "The brief's `atlas_anchors` is ONE source. Before committing any role pick "
     "you MUST also query the other three sources below. Factory-atlas-only picks "

package/mcp_server/evaluation/feature_extractors.py

@@ -9,7 +9,7 @@ All returned values are clamped to 0.0-1.0 for consistent scoring.
 from __future__ import annotations
 
 import math
-from typing import Optional
+from typing import Any, Optional
 
 from ..tools._evaluation_contracts import MEASURABLE_DIMENSIONS
 
@@ -19,6 +19,42 @@ def _clamp(value: float, lo: float = 0.0, hi: float = 1.0) -> float:
     return max(lo, min(hi, value))
 
 
+def _number(value: Any) -> Optional[float]:
+    """Best-effort numeric coercion for analyzer payloads."""
+    if isinstance(value, bool):
+        return float(value)
+    if isinstance(value, (int, float)):
+        return float(value)
+    return None
+
+
+def _nested_number(payload: Any, *keys: str) -> Optional[float]:
+    """Read a numeric value from a dict payload using candidate keys."""
+    if isinstance(payload, dict):
+        for key in keys:
+            value = _number(payload.get(key))
+            if value is not None:
+                return value
+    return _number(payload)
+
+
+def _centroid_to_unit(centroid: float) -> float:
+    """Map centroid-like values to 0..1.
+
+    FluCoMa deployments may report centroid in Hz or normalized units.
+    Values <= 1 are treated as normalized. Larger values are mapped across
+    a practical musical range where 150 Hz is very dark and 8 kHz is bright.
+    """
+    if centroid <= 1.0:
+        return _clamp(centroid)
+    return _clamp((centroid - 150.0) / (8000.0 - 150.0))
+
+
+def _lufs_to_unit(lufs: float) -> float:
+    """Map momentary LUFS to a rough 0..1 energy proxy."""
+    return _clamp((lufs + 60.0) / 60.0)
+
+
 def extract_dimension_value(
     snapshot: dict,
     dimension: str,
@@ -37,31 +73,49 @@ def extract_dimension_value(
     if not snapshot or not isinstance(snapshot, dict):
         return None
 
-    bands = snapshot.get("spectrum")
-    if not bands:
-        return None
+    bands = snapshot.get("spectrum") or {}
+    spectral_shape = snapshot.get("spectral_shape") or {}
+    onset = snapshot.get("onset") or {}
+    novelty = snapshot.get("novelty") or {}
+    loudness = snapshot.get("loudness") or {}
 
     rms = snapshot.get("rms")
     peak = snapshot.get("peak")
 
     if dimension == "brightness":
+        centroid = _nested_number(spectral_shape, "centroid", "centroid_hz")
+        if centroid is not None:
+            return _centroid_to_unit(centroid)
+        if not bands:
+            return None
         high = bands.get("high", 0)
         presence = bands.get("presence", 0)
         return _clamp((high + presence) / 2.0)
 
     elif dimension == "warmth":
+        if not bands:
+            return None
         return _clamp(bands.get("low_mid", 0))
 
     elif dimension == "weight":
-        sub = bands.get("sub", 0)
+        if not bands:
+            return None
+        sub = bands.get("sub_low", bands.get("sub", 0))
         low = bands.get("low", 0)
         return _clamp((sub + low) / 2.0)
 
     elif dimension == "clarity":
+        if not bands:
+            return None
         low_mid = bands.get("low_mid", 0)
         return _clamp(1.0 - low_mid)
 
     elif dimension == "density":
+        flatness = _nested_number(spectral_shape, "flatness", "spectral_flatness")
+        if flatness is not None:
+            return _clamp(flatness)
+        if not bands:
+            return None
         vals = [max(v, 1e-10) for v in bands.values()
                 if isinstance(v, (int, float))]
         if not vals:
@@ -71,14 +125,104 @@ def extract_dimension_value(
         return _clamp(geo_mean / max(arith_mean, 1e-10))
 
     elif dimension == "energy":
-        return _clamp(rms) if rms is not None else None
+        rms_value = _number(rms)
+        if rms_value is not None:
+            return _clamp(rms_value)
+        lufs = _nested_number(loudness, "momentary_lufs", "lufs", "integrated_lufs")
+        if lufs is not None:
+            return _lufs_to_unit(lufs)
+        return None
 
     elif dimension == "punch":
-        if rms and peak and rms > 0:
-            crest_db = 20.0 * math.log10(max(peak / rms, 1.0))
+        rms_value = _number(rms)
+        peak_value = _number(peak)
+        if rms_value and peak_value and rms_value > 0:
+            crest_db = 20.0 * math.log10(max(peak_value / rms_value, 1.0))
             return _clamp(crest_db / 20.0)
+        onset_strength = _nested_number(onset, "strength", "onset")
+        if onset_strength is not None:
+            return _clamp(onset_strength)
+        spectral_crest = _nested_number(spectral_shape, "crest")
+        if spectral_crest is not None:
+            return _clamp(spectral_crest)
+        return None
+
+    elif dimension == "novelty":
+        novelty_score = _nested_number(novelty, "score", "novelty", "value")
+        return _clamp(novelty_score) if novelty_score is not None else None
+
+    elif dimension == "motion":
+        novelty_score = _nested_number(novelty, "score", "novelty", "value")
+        onset_strength = _nested_number(onset, "strength", "onset")
+        vals = [v for v in (novelty_score, onset_strength) if v is not None]
+        if vals:
+            return _clamp(sum(vals) / len(vals))
         return None
 
     else:
         # Unmeasurable dimension
         return None
+
+
+def _label_low_mid_high(value: float, low: str, mid: str, high: str) -> str:
+    if value < 0.33:
+        return low
+    if value > 0.67:
+        return high
+    return mid
+
+
+def extract_character_profile(snapshot: dict) -> dict:
+    """Summarize analyzer data as a production-oriented character profile.
+
+    This is intentionally descriptive, not prescriptive. Engines can attach
+    the profile to their analysis response so the agent chooses sound-source,
+    device, and parameter moves before reaching for generic level changes.
+    """
+    if not snapshot or not isinstance(snapshot, dict):
+        return {"available": False, "values": {}, "labels": {}, "biases": []}
+
+    dimensions = (
+        "brightness", "warmth", "weight", "clarity", "density",
+        "energy", "punch", "motion", "novelty",
+    )
+    values = {
+        dim: round(val, 4)
+        for dim in dimensions
+        if (val := extract_dimension_value(snapshot, dim)) is not None
+    }
+
+    labels: dict[str, str] = {}
+    if "brightness" in values:
+        labels["brightness"] = _label_low_mid_high(values["brightness"], "dark", "balanced", "bright")
+    if "warmth" in values:
+        labels["warmth"] = _label_low_mid_high(values["warmth"], "lean", "warm", "thick")
+    if "weight" in values:
+        labels["weight"] = _label_low_mid_high(values["weight"], "light", "grounded", "heavy")
+    if "density" in values:
+        labels["density"] = _label_low_mid_high(values["density"], "peaked", "shaped", "flat/noisy")
+    if "punch" in values:
+        labels["punch"] = _label_low_mid_high(values["punch"], "soft", "defined", "spiky")
+    if "motion" in values:
+        labels["motion"] = _label_low_mid_high(values["motion"], "static", "moving", "busy")
+
+    biases: list[str] = []
+    if values.get("brightness", 0.5) > 0.72:
+        biases.append("prefer filter tone, source choice, or de-harshing over lowering track volume")
+    if values.get("brightness", 0.5) < 0.28:
+        biases.append("prefer oscillator/filter opening, excitation, or air-band source choice over level boosts")
+    if values.get("motion", 0.5) < 0.25:
+        biases.append("prefer modulation, envelope drift, or evolving devices before static mix moves")
+    if values.get("punch", 0.5) < 0.25:
+        biases.append("prefer envelope/transient shaping or source layering before pushing volume")
+    if values.get("density", 0.0) > 0.75:
+        biases.append("prefer subtractive filtering or simpler source selection when the spectrum is flat/noisy")
+    if values.get("weight", 0.5) < 0.25:
+        biases.append("prefer instrument/register/source changes for low-end weight before master gain")
+
+    return {
+        "available": bool(values),
+        "values": values,
+        "labels": labels,
+        "biases": biases,
+    }

package/mcp_server/mix_engine/state_builder.py

@@ -68,6 +68,19 @@ def _name_signals_non_anchor(track_name: str) -> bool:
 # Frequency bands where masking is most problematic.
 _MASKING_BANDS = ("sub", "low", "low_mid", "mid", "high_mid", "presence", "high")
 
+_MASKING_ROLE_ALIASES = {
+    "sub_bass": "bass",
+    "hihat": "percussion",
+    "hat": "percussion",
+    "clap": "percussion",
+    "snare": "percussion",
+}
+
+
+def _masking_role(role: str) -> str:
+    """Normalize detailed track roles into the collision-rule vocabulary."""
+    return _MASKING_ROLE_ALIASES.get(role, role)
+
 
 # ── Balance ─────────────────────────────────────────────────────────
 
@@ -164,7 +177,7 @@ def build_masking_map(
     # Build role->indices mapping
     role_to_indices: dict[str, list[int]] = {}
     for idx, role in track_roles.items():
-        role_to_indices.setdefault(role, []).append(idx)
+        role_to_indices.setdefault(_masking_role(role), []).append(idx)
 
     # Known problematic role pairs and their collision bands
     collision_rules: list[tuple[str, str, str, float]] = [
@@ -267,7 +280,11 @@ def build_mix_state(
     role_hints = role_hints or {}
 
     balance = build_balance_state(track_infos, role_hints)
-    masking = build_masking_map(spectrum, role_hints)
+    inferred_roles = {
+        track.track_index: role_hints.get(track.track_index, track.role)
+        for track in balance.track_states
+    }
+    masking = build_masking_map(spectrum, inferred_roles)
 
     # Extract peak from spectrum if available
     peak = None

package/mcp_server/mix_engine/tools.py

@@ -11,6 +11,7 @@ from fastmcp import Context
 from ..server import mcp
 from ..tools._evaluation_contracts import EvaluationRequest
 from ..tools._snapshot_normalizer import normalize_sonic_snapshot
+from ..evaluation.feature_extractors import extract_character_profile
 from ..evaluation.fabric import evaluate_sonic_move
 from .state_builder import build_mix_state
 from .critics import run_all_mix_critics
@@ -56,6 +57,18 @@ def _fetch_mix_data(ctx: Context) -> dict:
             rms_snap = spectral.get("rms")
             if rms_snap:
                 rms_data = rms_snap["value"] if isinstance(rms_snap["value"], dict) else rms_snap["value"]
+                if spectrum is not None:
+                    spectrum["rms"] = rms_data.get("rms") if isinstance(rms_data, dict) else rms_data
+            peak_snap = spectral.get("peak")
+            if peak_snap and spectrum is not None:
+                spectrum["peak"] = peak_snap["value"]
+
+            for key in ("spectral_shape", "mel_bands", "chroma", "onset", "novelty", "loudness"):
+                snap = spectral.get(key)
+                if snap:
+                    if spectrum is None:
+                        spectrum = {}
+                    spectrum[key] = snap["value"]
     except Exception as exc:
         logger.debug("_fetch_mix_data failed: %s", exc)
 
@@ -86,9 +99,12 @@ def analyze_mix(ctx: Context) -> dict:
     )
     issues = run_all_mix_critics(mix_state)
     moves = plan_mix_moves(issues, mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
+    sonic_character = extract_character_profile(sonic_snapshot or {})
 
     return {
         "mix_state": mix_state.to_dict(),
+        "sonic_character": sonic_character,
         "issues": [i.to_dict() for i in issues],
         "suggested_moves": [m.to_dict() for m in moves],
         "issue_count": len(issues),
@@ -110,8 +126,10 @@ def get_mix_issues(ctx: Context) -> dict:
         rms_data=data["rms_data"],
     )
     issues = run_all_mix_critics(mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
 
     return {
+        "sonic_character": extract_character_profile(sonic_snapshot or {}),
         "issues": [i.to_dict() for i in issues],
         "issue_count": len(issues),
     }
@@ -133,8 +151,10 @@ def plan_mix_move(ctx: Context) -> dict:
     )
     issues = run_all_mix_critics(mix_state)
     moves = plan_mix_moves(issues, mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
 
     return {
+        "sonic_character": extract_character_profile(sonic_snapshot or {}),
         "moves": [m.to_dict() for m in moves],
         "move_count": len(moves),
         "issue_count": len(issues),
@@ -212,10 +232,12 @@ def get_mix_summary(ctx: Context) -> dict:
         rms_data=data["rms_data"],
     )
     issues = run_all_mix_critics(mix_state)
+    sonic_snapshot = normalize_sonic_snapshot(data["spectrum"], source="mix_engine")
 
     return {
         "track_count": len(mix_state.balance.track_states),
         "issue_count": len(issues),
+        "sonic_character": extract_character_profile(sonic_snapshot or {}),
         "dynamics": mix_state.dynamics.to_dict(),
         "stereo": mix_state.stereo.to_dict(),
         "depth": mix_state.depth.to_dict(),

package/mcp_server/sound_design/tools.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 from fastmcp import Context
 
 from ..server import mcp
+from ..evaluation.feature_extractors import extract_character_profile
+from ..tools._snapshot_normalizer import normalize_sonic_snapshot
 from .models import (
     LayerStrategy,
     PatchBlock,
@@ -189,9 +191,36 @@ def _fetch_sound_design_data(ctx: Context, track_index: int) -> dict:
     # Get devices from track_info response (already included by Remote Script)
     devices: list[dict] = track_info.get("devices", [])
 
+    sonic = None
+    try:
+        spectral = ctx.lifespan_context.get("spectral")
+        if spectral and spectral.is_connected:
+            sonic = {}
+            spec_data = spectral.get("spectrum")
+            if spec_data:
+                sonic["bands"] = spec_data["value"]
+            rms_snap = spectral.get("rms")
+            if rms_snap:
+                sonic["rms"] = rms_snap["value"]
+            peak_snap = spectral.get("peak")
+            if peak_snap:
+                sonic["peak"] = peak_snap["value"]
+            key_snap = spectral.get("key")
+            if key_snap:
+                sonic["detected_key"] = key_snap["value"]
+            for key in ("spectral_shape", "mel_bands", "chroma", "onset", "novelty", "loudness"):
+                snap = spectral.get(key)
+                if snap:
+                    sonic[key] = snap["value"]
+            if not sonic:
+                sonic = None
+    except Exception:
+        sonic = None
+
     return {
         "track_info": track_info,
         "devices": devices,
+        "sonic_snapshot": normalize_sonic_snapshot(sonic, source="sound_design"),
     }
 
 
@@ -262,9 +291,11 @@ def analyze_sound_design(ctx: Context, track_index: int) -> dict:
         issues, data["track_info"].get("name", "")
     )
     moves = plan_sound_design_moves(issues, state)
+    sonic_character = extract_character_profile(data.get("sonic_snapshot") or {})
 
     return {
         "state": state.to_dict(),
+        "sonic_character": sonic_character,
         "issues": [i.to_dict() for i in issues],
         "suggested_moves": [m.to_dict() for m in moves],
         "issue_count": len(issues),
@@ -295,6 +326,7 @@ def get_sound_design_issues(ctx: Context, track_index: int) -> dict:
     )
 
     return {
+        "sonic_character": extract_character_profile(data.get("sonic_snapshot") or {}),
         "issues": [i.to_dict() for i in issues],
         "issue_count": len(issues),
     }
@@ -330,6 +362,7 @@ def plan_sound_design_move(ctx: Context, track_index: int) -> dict:
     moves = plan_sound_design_moves(issues, state)
 
     result: dict = {
+        "sonic_character": extract_character_profile(data.get("sonic_snapshot") or {}),
         "moves": [m.to_dict() for m in moves],
         "move_count": len(moves),
         "issue_count": len(issues),

package/mcp_server/tools/_agent_os_engine/evaluation.py

@@ -11,6 +11,10 @@ import re
 from dataclasses import asdict, dataclass, field
 from typing import Any, Optional
 
+from ...evaluation.feature_extractors import (
+    extract_dimension_value as _shared_extract_dimension_value,
+)
+from .._snapshot_normalizer import normalize_sonic_snapshot
 from .models import QUALITY_DIMENSIONS, GoalVector, WorldModel, _clamp
 from .taste import compute_taste_fit
 
@@ -29,50 +33,10 @@ def _extract_dimension_value(
     """
     if not sonic:
         return None
-    # Accept both "spectrum" and "bands" keys — get_master_spectrum returns
-    # {"bands": {...}} while the evaluator historically expected {"spectrum": {...}}.
-    # Finding 2 fix: tolerate either shape so raw analyzer output works.
-    bands = sonic.get("spectrum") or sonic.get("bands")
-    if not bands:
-        return None
-    rms = sonic.get("rms")
-    peak = sonic.get("peak")
-
-    if dimension == "brightness":
-        high = bands.get("high", 0)
-        presence = bands.get("presence", 0)
-        return _clamp((high + presence) / 2.0)
-    elif dimension == "warmth":
-        return _clamp(bands.get("low_mid", 0))
-    elif dimension == "weight":
-        sub = bands.get("sub", 0)
-        low = bands.get("low", 0)
-        return _clamp((sub + low) / 2.0)
-    elif dimension == "clarity":
-        low_mid = bands.get("low_mid", 0)
-        return _clamp(1.0 - low_mid)
-    elif dimension == "density":
-        # Spectral flatness: geometric mean / arithmetic mean of band values.
-        # Higher = more evenly distributed energy (noise-like).
-        # Lower = more tonal (energy concentrated in few bands).
-        vals = [max(v, 1e-10) for v in bands.values() if isinstance(v, (int, float))]
-        if not vals:
-            return None
-        geo_mean = math.exp(sum(math.log(v) for v in vals) / len(vals))
-        arith_mean = sum(vals) / len(vals)
-        return _clamp(geo_mean / max(arith_mean, 1e-10))
-    elif dimension == "energy":
-        return _clamp(rms) if rms is not None else None
-    elif dimension == "punch":
-        if rms and peak and rms > 0:
-            crest_db = 20.0 * math.log10(max(peak / rms, 1.0))
-            # Normalize: 0 dB = 0.0, 20 dB = 1.0
-            return _clamp(crest_db / 20.0)
-        return None
-    else:
-        # Unmeasurable in Phase 1 (width, depth, motion, contrast,
-        # groove, tension, novelty, polish, emotion, cohesion)
+    normalized = normalize_sonic_snapshot(sonic, source="agent_os")
+    if normalized is None:
         return None
+    return _shared_extract_dimension_value(normalized, dimension)
 
 def compute_evaluation_score(
     goal: GoalVector,
@@ -203,4 +167,3 @@ def compute_evaluation_score(
         # I5: hint for the agent to track consecutive undos
         "consecutive_undo_hint": not keep_change,
     }
-

package/mcp_server/tools/_agent_os_engine/models.py

@@ -33,6 +33,8 @@ MEASURABLE_PROXIES: dict[str, str] = {
     "density": "spectral flatness (geometric/arithmetic mean ratio)",
     "energy": "RMS level",
     "punch": "crest factor in dB (20*log10(peak/rms))",
+    "motion": "spectral novelty + onset strength",
+    "novelty": "FluCoMa novelty score",
 }
 
 VALID_MODES = frozenset({"observe", "improve", "explore", "finish", "diagnose"})
@@ -129,4 +131,3 @@ class TechniqueCard:
             "verification": self.verification,
             "evidence": self.evidence,
         }
-

package/mcp_server/tools/_conductor.py

@@ -70,7 +70,7 @@ class ConductorPlan:
 _ROUTING_PATTERNS: list[tuple[str, str, str, str, list[str]]] = [
     # Mix requests
     (r"clean|mud|muddy|low.?mid|eq|equaliz", "mix_engine", "mix", "analyze_mix", ["plan_mix_move", "evaluate_mix_move"]),
-    (r"punch|punchy|transient|dynamics|compress", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
+    (r"dynamics|compress|crest|over.?compress|flat.?dynamics", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
     (r"wide|wider|width|stereo|narrow|mono.?compat", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
     (r"glue|cohes|bus.?comp|mix.?bus", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
     (r"balance|level|volume.?balanc|gain.?stag", "mix_engine", "mix", "analyze_mix", ["plan_mix_move"]),
@@ -87,6 +87,7 @@ _ROUTING_PATTERNS: list[tuple[str, str, str, str, list[str]]] = [
 
     # Sound design requests
     (r"synth|patch|oscillat|timbre|timbral|wavetable|operator", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
+    (r"punch|punchy|hit.?harder|snap|attack|transient", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
     (r"haunted|lush|aggressive|warm.?pad|fat.?bass|bright.?lead", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
     (r"modulation|lfo|movement|evolv|texture", "sound_design", "sound_design", "get_patch_model", ["analyze_sound_design"]),
     (r"layer|sub.?layer|transient.?layer|body", "sound_design", "sound_design", "analyze_sound_design", ["plan_sound_design_move"]),
@@ -254,7 +255,7 @@ def classify_request(request: str) -> ConductorPlan:
 
     # Determine capability requirements
     caps = ["session_access"]
-    if any(r.engine == "mix_engine" for r in routes):
+    if any(r.engine in ("mix_engine", "sound_design") for r in routes):
         caps.append("analyzer")
     if any(r.engine in ("reference_engine",) for r in routes):
         caps.append("offline_perception")
@@ -267,6 +268,8 @@ def classify_request(request: str) -> ConductorPlan:
         notes.append("Multi-engine task — start with get_session_kernel for shared state")
     if any(r.engine == "mix_engine" for r in routes):
         notes.append("Mix engine works best with analyzer data — check get_capability_state")
+    if any(r.engine == "sound_design" for r in routes):
+        notes.append("Sound design should use analyzer character before level or pan changes")
 
     # V2: Search semantic moves for matching intents
     semantic_moves = _find_matching_semantic_moves(lower)

package/mcp_server/tools/_evaluation_contracts.py

@@ -22,7 +22,7 @@ from typing import Optional
 # must report confidence=0.0 for that dimension.
 MEASURABLE_DIMENSIONS: frozenset[str] = frozenset({
     "brightness", "warmth", "weight", "clarity",
-    "density", "energy", "punch",
+    "density", "energy", "punch", "motion", "novelty",
 })
 
 # All valid quality dimensions (measurable + unmeasurable).

package/mcp_server/tools/_snapshot_normalizer.py

@@ -13,6 +13,18 @@ import time
 from typing import Optional
 
 
+_RICH_ANALYZER_KEYS = (
+    "spectral_shape",
+    "mel_bands",
+    "chroma",
+    "onset",
+    "onsets",
+    "novelty",
+    "loudness",
+    "sub_detail",
+)
+
+
 def normalize_sonic_snapshot(
     raw: Optional[dict],
     source: str = "unknown",
@@ -20,6 +32,9 @@ def normalize_sonic_snapshot(
     """Normalize a raw analyzer/perception output into canonical snapshot form.
 
     Accepts both {"bands": {...}} and {"spectrum": {...}} shapes.
+    Rich analyzer streams are preserved when present so evaluators can
+    reason from FluCoMa character descriptors instead of collapsing every
+    decision down to the 9-band spectrum.
     Returns None if input is empty or None.
 
     Canonical form:
@@ -28,6 +43,12 @@ def normalize_sonic_snapshot(
         "rms": float or None,
         "peak": float or None,
         "detected_key": str or None,
+        "spectral_shape": dict or None,
+        "mel_bands": list or None,
+        "chroma": dict/list or None,
+        "onset": dict or None,
+        "novelty": dict or None,
+        "loudness": dict or None,
         "source": str,
         "normalized_at_ms": int,
     }
@@ -35,11 +56,12 @@ def normalize_sonic_snapshot(
     if not raw or not isinstance(raw, dict):
         return None
 
-    bands = raw.get("spectrum") or raw.get("bands")
-    if not bands:
+    bands = raw.get("spectrum") or raw.get("bands") or {}
+    has_rich_analyzer_data = any(raw.get(k) is not None for k in _RICH_ANALYZER_KEYS)
+    if not bands and not has_rich_analyzer_data:
         return None
 
-    return {
+    normalized = {
         "spectrum": bands,
         "rms": raw.get("rms"),
         "peak": raw.get("peak"),
@@ -47,3 +69,10 @@ def normalize_sonic_snapshot(
         "source": source,
         "normalized_at_ms": int(time.time() * 1000),
     }
+
+    for key in _RICH_ANALYZER_KEYS:
+        if key in raw and raw.get(key) is not None:
+            out_key = "onset" if key == "onsets" else key
+            normalized[out_key] = raw.get(key)
+
+    return normalized

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livepilot",
-  "version": "1.26.1",
+  "version": "1.26.2",
   "mcpName": "io.github.dreamrec/livepilot",
   "description": "Agentic production system for Ableton Live 12 — 465 tools, 56 domains, 44 semantic moves. Device atlas (5264 devices, 120 enriched, 7 indexes), Splice intelligence (gRPC + GraphQL describe-a-sound + preview + collections + presets), 9-band spectral perception auto-loaded via ensure_analyzer_on_master, Creative Director skill, technique memory, 12 creative intelligence engines",
   "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.26.1"
+__version__ = "1.26.2"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/dreamrec/LivePilot",
     "source": "github"
   },
-  "version": "1.26.1",
+  "version": "1.26.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "livepilot",
-      "version": "1.26.1",
+      "version": "1.26.2",
       "transport": {
         "type": "stdio"
       }