livepilot 1.26.1 → 1.27.0

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

@@ -28,20 +28,20 @@ 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.
+Current: **467 tools across 56 domains**.
+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}'`
 
 Files that reference tool count:
-- [ ] `README.md` — header ("465 tools. 56 domains"), bridge section ("38 spectral/analyzer tools require bridge")
+- [ ] `README.md` — header ("467 tools. 56 domains"), bridge section ("38 spectral/analyzer tools require bridge")
 - [ ] `package.json` → `"description"`
 - [ ] `server.json` → `"description"`
 - [ ] `manifest.json` → `"description"`
 - [ ] `livepilot/.Codex-plugin/plugin.json` → `"description"` (primary Codex manifest)
 - [ ] `livepilot/.claude-plugin/plugin.json` → `"description"` (must match Codex plugin)
 - [ ] `.claude-plugin/marketplace.json` → `"description"`
-- [ ] `CLAUDE.md` → "465 tools across 56 domains"
+- [ ] `CLAUDE.md` → "467 tools across 56 domains"
 - [ ] `CONTRIBUTING.md` → tool count in intro
 - [ ] `livepilot/skills/livepilot-core/SKILL.md` — tool/domain count
 - [ ] `livepilot/skills/livepilot-core/references/overview.md` — tool/domain count
@@ -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
 
@@ -85,6 +85,8 @@ Current: **56 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 
 ## 6. Plugin Cache
 
+- [ ] `python3 scripts/verify_codex_plugin_sync.py` passes after `npx livepilot --install-codex-plugin`
+- [ ] `python3 scripts/verify_plugin_sync.py` passes after Claude plugin cache/mirror sync
 - [ ] `~/.claude/plugins/cache/dreamrec-LivePilot/livepilot/` has current version directory
 - [ ] Old version directories removed
 - [ ] `~/.claude/plugins/installed_plugins.json` → `livepilot@dreamrec-LivePilot` entry: update `version`, `installPath`, `gitCommitSha`, `lastUpdated`
@@ -98,7 +100,7 @@ Current: **56 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 
 - [ ] `README.md` — features match current capabilities, "Coming" section is accurate
 - [ ] `docs/manual/getting-started.md` — install instructions current
-- [ ] `docs/manual/tool-reference.md` — all 56 domains listed, all 465 tools present
+- [ ] `docs/manual/tool-reference.md` — all 56 domains listed, all 467 tools present
 - [ ] `docs/M4L_BRIDGE.md` — architecture accurate, core/bridge counts correct
 
 ## 9. Derived Artifacts
@@ -147,5 +149,5 @@ Current: **56 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 ## Quick Verify Command
 
 ```bash
-echo "=== Versions ===" && grep -h '"version"' package.json server.json manifest.json livepilot/.Codex-plugin/plugin.json livepilot/.claude-plugin/plugin.json .claude-plugin/marketplace.json | head -8 && grep __version__ mcp_server/__init__.py remote_script/LivePilot/__init__.py && echo "=== Tool count ===" && grep -rc "@mcp.tool" mcp_server/ | grep -v ":0" | awk -F: '{sum+=$2} END{print "Total:", sum}' && echo "=== Tests ===" && python3 -m pytest tests/ -q 2>&1 | tail -1
+echo "=== Versions ===" && grep -h '"version"' package.json server.json manifest.json livepilot/.Codex-plugin/plugin.json livepilot/.claude-plugin/plugin.json .claude-plugin/marketplace.json | head -8 && grep __version__ mcp_server/__init__.py remote_script/LivePilot/__init__.py && echo "=== Metadata ===" && python3 scripts/sync_metadata.py --check && echo "=== Plugin sync ===" && python3 scripts/verify_codex_plugin_sync.py --quiet && python3 scripts/verify_plugin_sync.py --quiet && echo "=== Tests ===" && python3 -m pytest tests/ -q 2>&1 | tail -1
 ```

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.27.0";
 
 // ── 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.27.0"

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/runtime/capability_probe.py

@@ -73,7 +73,7 @@ def probe_capabilities(
         bridge_ok = bridge is not None and spectral is not None and getattr(spectral, "is_connected", False)
     report["m4l_bridge"] = {
         "status": "ok" if bridge_ok else "unavailable",
-        "detail": "UDP 9880 / OSC 9881 active" if bridge_ok else "Not connected — 30 analyzer tools unavailable",
+        "detail": "UDP 9880 / OSC 9881 active" if bridge_ok else "Not connected — 38 analyzer tools unavailable",
     }
 
     # 4. Offline perception

package/mcp_server/runtime/capability_state.py

@@ -118,6 +118,12 @@ def build_capability_state(
     memory_ok: bool = False,
     web_ok: bool = False,
     flucoma_ok: bool = False,
+    flucoma_device_loaded: Optional[bool] = None,
+    flucoma_reasons: Optional[list[str]] = None,
+    link_audio_mode: str = "manual_only",
+    link_audio_reasons: Optional[list[str]] = None,
+    stem_workflow_mode: str = "manual_only",
+    stem_workflow_reasons: Optional[list[str]] = None,
 ) -> CapabilityState:
     """Build a CapabilityState from simple boolean probes.
 
@@ -200,19 +206,70 @@ def build_capability_state(
     )
 
     # ── flucoma ──────────────────────────────────────────────────────
-    # Optional dependency (the ``flucoma`` Python package).  Emitted
-    # unconditionally so consumers can distinguish "probed and missing"
-    # from "probe not run yet".
-    flucoma_reasons: list[str] = []
-    if not flucoma_ok:
-        flucoma_reasons.append("flucoma_not_installed")
+    # Max/FluCoMa real-time streams. Emitted unconditionally so consumers
+    # can distinguish "not installed" from "installed but bridge/streams
+    # are currently unavailable".
+    resolved_flucoma_device_loaded = (
+        flucoma_ok if flucoma_device_loaded is None else flucoma_device_loaded
+    )
+    resolved_flucoma_reasons = list(flucoma_reasons or [])
+    if not flucoma_ok and not resolved_flucoma_reasons:
+        resolved_flucoma_reasons.append(
+            "flucoma_no_streams"
+            if resolved_flucoma_device_loaded
+            else "flucoma_not_installed"
+        )
     domains["flucoma"] = CapabilityDomain(
         name="flucoma",
         available=flucoma_ok,
-        confidence=0.9 if flucoma_ok else 0.0,
+        confidence=0.9 if flucoma_ok else (0.2 if resolved_flucoma_device_loaded else 0.0),
         mode="available" if flucoma_ok else "unavailable",
-        reasons=flucoma_reasons,
-        device_loaded=flucoma_ok,
+        reasons=resolved_flucoma_reasons,
+        device_loaded=resolved_flucoma_device_loaded,
+    )
+
+    # ── link_audio ────────────────────────────────────────────────────
+    # Live 12.4 exposes Link Audio in the product UX, but LivePilot must
+    # not claim automation support from the version number alone. This
+    # domain only becomes available when runtime probing observes a stable
+    # readable/routable surface.
+    link_mode = link_audio_mode if session_ok else "unavailable"
+    link_reasons = list(link_audio_reasons or [])
+    if not link_reasons:
+        if not session_ok:
+            link_reasons.append("session_unavailable")
+        elif link_mode == "manual_only":
+            link_reasons.append("link_audio_unprobed")
+        elif link_mode == "unavailable":
+            link_reasons.append("link_audio_not_exposed")
+    link_available = link_mode in {"readable", "routable"}
+    domains["link_audio"] = CapabilityDomain(
+        name="link_audio",
+        available=link_available,
+        confidence=0.8 if link_available else (0.2 if session_ok else 0.0),
+        mode=link_mode,
+        reasons=link_reasons,
+    )
+
+    # ── stem_workflow ─────────────────────────────────────────────────
+    # Selected-time stem separation / merge are also probe-first. The
+    # safe default is manual_only; callable only after concrete evidence.
+    stem_mode = stem_workflow_mode if session_ok else "unavailable"
+    stem_reasons = list(stem_workflow_reasons or [])
+    if not stem_reasons:
+        if not session_ok:
+            stem_reasons.append("session_unavailable")
+        elif stem_mode == "manual_only":
+            stem_reasons.append("stem_workflow_unprobed")
+        elif stem_mode == "unavailable":
+            stem_reasons.append("stem_workflow_not_exposed")
+    stem_available = stem_mode == "callable"
+    domains["stem_workflow"] = CapabilityDomain(
+        name="stem_workflow",
+        available=stem_available,
+        confidence=0.8 if stem_available else (0.2 if session_ok else 0.0),
+        mode=stem_mode,
+        reasons=stem_reasons,
     )
 
     # ── research (composite) ────────────────────────────────────────

package/mcp_server/runtime/live_version.py

@@ -72,6 +72,21 @@ class LiveVersionCapabilities:
         """Stem separation via MFL — 12.3+"""
         return self._version_tuple >= (12, 3, 0)
 
+    @property
+    def has_link_audio(self) -> bool:
+        """Live 12.4 Link Audio UX exists; MCP control remains probe-gated."""
+        return self._version_tuple >= (12, 4, 0)
+
+    @property
+    def has_stem_time_selection(self) -> bool:
+        """Live 12.4 selected-time stem separation UX exists; probe before use."""
+        return self._version_tuple >= (12, 4, 0)
+
+    @property
+    def has_stem_merge_selected(self) -> bool:
+        """Live 12.4 merge-selected-stems UX exists; probe before use."""
+        return self._version_tuple >= (12, 4, 0)
+
     @property
     def has_replace_sample_native(self) -> bool:
         """SimplerDevice.replace_sample(path) — 12.4+"""
@@ -100,5 +115,8 @@ class LiveVersionCapabilities:
             "drum_rack_construction": self.has_drum_rack_construction,
             "take_lanes": self.has_take_lanes,
             "stem_separation": self.has_stem_separation,
+            "link_audio": self.has_link_audio,
+            "stem_time_selection": self.has_stem_time_selection,
+            "stem_merge_selected": self.has_stem_merge_selected,
             "replace_sample_native": self.has_replace_sample_native,
         }

package/mcp_server/runtime/session_kernel.py

@@ -60,6 +60,11 @@ class SessionKernel:
     # may add "sculptor". Empty string = producer picks a default.
     creativity_profile: str = ""
 
+    # v1.27 operation posture. This is intentionally descriptive at the
+    # kernel layer; engines can opt into stricter behavior without forcing
+    # every tool to know every profile immediately.
+    operation_profile: str = "studio_deep"
+
     # Caller-asserted sacred elements. Normally sacred elements come from
     # song_brain; this lets the user or a skill override. Shape matches
     # song_brain.sacred_elements entries: {element_type, description, salience}.
@@ -94,6 +99,7 @@ def build_session_kernel(
     # PR2 — creative controls. All optional; legacy callers unaffected.
     freshness: float = 0.5,
     creativity_profile: str = "",
+    operation_profile: str = "studio_deep",
     sacred_elements: Optional[list] = None,
     synth_hints: Optional[dict] = None,
 ) -> SessionKernel:
@@ -137,6 +143,7 @@ def build_session_kernel(
         protected_dimensions=protected_dimensions or {},
         freshness=freshness,
         creativity_profile=creativity_profile,
+        operation_profile=operation_profile,
         sacred_elements=sacred_elements or [],
         synth_hints=synth_hints or {},
     )