livepilot 1.25.0 → 1.26.1

package/mcp_server/grader/iterator.py

@@ -0,0 +1,57 @@
+"""Revision-brief formatter.
+
+Phase 1 — produces a markdown brief for the orchestrating agent (Claude Code
+or composer planner) when a verdict fails. The agent is responsible for
+deciding whether to retry; this module only formats the feedback.
+
+Autonomous iteration loops land in Phase 2 once the rubric set is broader.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_revision_brief(verdict: dict[str, Any]) -> str:
+    """Markdown brief surfacing non-pass criteria.
+
+    Returns empty string only when there are zero `fail` and zero `warn`
+    criteria. A verdict can pass overall (no blocking failures) yet still
+    have advisory warnings worth surfacing — those produce an Advisory-only
+    brief.
+    """
+    failed = [c for c in verdict["criteria"] if c["severity"] == "fail"]
+    warns = [c for c in verdict["criteria"] if c["severity"] == "warn"]
+
+    if not failed and not warns:
+        return ""
+
+    headline = "needs revision" if failed else "review advisory items"
+    lines: list[str] = [
+        f"# Rubric `{verdict['rubric_id']}` — {headline}",
+        "",
+    ]
+
+    if failed:
+        lines.append("## Blocking failures")
+        for c in failed:
+            lines.append(f"### {c['id']}")
+            lines.append(f"- **summary:** {c['summary']}")
+            for issue in c["issues"]:
+                track = issue.get("track_index")
+                track_ref = f" (track {track})" if track is not None else ""
+                lines.append(f"- {issue['code']}{track_ref}: {issue['detail']}")
+            lines.append("")
+
+    if warns:
+        lines.append("## Advisory (non-blocking)")
+        for c in warns:
+            lines.append(f"### {c['id']}")
+            lines.append(f"- **summary:** {c['summary']}")
+            for issue in c["issues"]:
+                track = issue.get("track_index")
+                track_ref = f" (track {track})" if track is not None else ""
+                lines.append(f"- {issue['code']}{track_ref}: {issue['detail']}")
+            lines.append("")
+
+    return "\n".join(lines).rstrip() + "\n"

package/mcp_server/grader/tools.py

@@ -0,0 +1,263 @@
+"""Grader MCP tools — Phases 2c-α (light) + 2c-β (heavy).
+
+Tools:
+- `grader_list_rubrics()` — names of registered rubrics
+- `grader_evaluate(rubric_id, heavy=False)` — fetches session state and
+  runs rubric. Light state covers `layer_accumulation`,
+  `default_preset_check`, plus the role+volume parts of every rubric.
+  Heavy state adds per-clip notes, per-clip automation, wavetable
+  mod-matrix, and session-level masking — required for `layer_precision`
+  to produce non-n/a verdicts on `sequence_per_track`,
+  `modulation_per_track`, and `masking_per_track`, and for
+  `modulation_presence` to leave the n/a state.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any
+
+from fastmcp import Context
+
+from ..server import mcp
+from ..audit.state import (
+    safe_call as _safe_call,
+    fetch_notes_for_clips as _fetch_notes_for_clips,
+    has_clip_automation as _has_clip_automation,
+    count_wavetable_routings as _count_wavetable_routings,
+)
+from . import client
+from . import iterator
+
+logger = logging.getLogger(__name__)
+
+
+def _get_ableton(ctx: Context):
+    return ctx.lifespan_context["ableton"]
+
+
+def _maybe_get_masking_report(ctx: Context) -> dict | None:
+    """Session-level masking report. Same pattern as audit_layer — calls
+    the mix_engine MCP tool's python function directly because masking
+    isn't a Remote Script command."""
+    try:
+        from ..mix_engine.tools import get_masking_report as _impl
+        return _impl(ctx)  # type: ignore[arg-type]
+    except Exception as exc:
+        logger.debug("grader heavy: masking fetch failed: %s", exc)
+        return None
+
+
+def _build_light_state(ctx: Context) -> dict[str, Any]:
+    """Light state — `get_session_info` + per-track `get_track_info`.
+
+    Sufficient for rubrics that only need track count, names, mixer,
+    devices. Skips per-clip and session-level heavy fetches.
+    """
+    ableton = _get_ableton(ctx)
+    session = _safe_call(ableton, "get_session_info") or {}
+    track_count = int(session.get("track_count") or 0)
+
+    tracks: list[dict[str, Any]] = []
+    for idx in range(track_count):
+        info = _safe_call(ableton, "get_track_info", {"track_index": idx})
+        if not info:
+            continue
+        if info.get("is_foldable") and info.get("is_master"):
+            continue
+        if info.get("is_return"):
+            continue
+        tracks.append({
+            "index": idx,
+            "name": info.get("name") or f"track_{idx}",
+            "mixer": info.get("mixer") or {},
+            "devices": info.get("devices") or [],
+            "clip_slots": info.get("clip_slots") or [],
+        })
+    return {"tracks": tracks, "fetched_at": time.time()}
+
+
+def _build_heavy_state(ctx: Context, include_masking: bool = True) -> dict[str, Any]:
+    """Heavy state — light + per-clip notes + per-clip automation +
+    wavetable mod-matrix + (optionally) session-level masking report.
+
+    Cost: O(tracks × clips) for notes/automation. Realistic budget per
+    evaluation: 5–15s on a 4-track session, 30–60s on a populated arrangement.
+    """
+    ableton = _get_ableton(ctx)
+    state = _build_light_state(ctx)
+    for t in state["tracks"]:
+        idx = t["index"]
+        clip_slots = t.get("clip_slots") or []
+        t["notes_per_clip"] = _fetch_notes_for_clips(ableton, idx, clip_slots)
+        t["has_clip_automation"] = _has_clip_automation(ableton, idx, clip_slots)
+        t["wavetable_mod_routings"] = _count_wavetable_routings(ableton, idx, t.get("devices") or [])
+
+    if include_masking:
+        masking_report = _maybe_get_masking_report(ctx)
+        if masking_report:
+            state["masking_report"] = masking_report
+
+    state["heavy"] = True
+    return state
+
+
+@mcp.tool()
+def grader_list_rubrics(ctx: Context) -> dict:
+    """List the rubrics the grader can evaluate.
+
+    Returns the rubric names registered in `mcp_server.grader.client`. Each
+    rubric corresponds to a binding rule from CLAUDE.md (§7.3, §1, §4, §5,
+    §2). See `livepilot/rubrics/<rubric_id>.md` for criteria detail.
+    """
+    return {
+        "rubrics": client.list_rubrics(),
+        "light_state_sufficient": [
+            "layer_accumulation",
+            "default_preset_check",
+        ],
+        "heavy_state_recommended": [
+            "modulation_presence",
+            "layer_precision",
+            "sound_design_depth",
+        ],
+    }
+
+
+@mcp.tool()
+def grader_evaluate(
+    ctx: Context,
+    rubric_id: str,
+    heavy: bool = False,
+    include_brief: bool = True,
+    include_masking: bool = True,
+) -> dict:
+    """Run a rubric across the current session, return verdict + brief.
+
+    State modes:
+        - heavy=False (default): `get_session_info` + per-track
+          `get_track_info`. ~3s on a 4-track session. Sufficient for
+          `layer_accumulation` and `default_preset_check`.
+        - heavy=True: adds per-clip `get_notes`, per-clip
+          `get_clip_automation`, per-Wavetable `get_wavetable_mod_matrix`,
+          and (when `include_masking=True`) session-level
+          `get_masking_report`. Required for `layer_precision` to produce
+          non-n/a verdicts on sequence/modulation/masking criteria, and
+          for `modulation_presence` to leave n/a.
+
+    Args:
+        rubric_id: Name of a registered rubric (see `grader_list_rubrics`).
+        heavy: When True, fetch per-clip + session-level signals. Slower
+            but needed for §4/§5 criteria beyond `stereo_per_track`.
+        include_brief: When True (default), attaches a markdown revision
+            brief formatted for an orchestrating agent.
+        include_masking: When True (default; only relevant when heavy=True),
+            includes the session-level masking report. Adds ~200–600ms.
+
+    Returns:
+        {
+            "rubric_id": str,
+            "passed": bool,
+            "criteria": [{id, severity, summary, issues, evidence}, ...],
+            "revision_brief": str,        # present when include_brief=True
+            "track_count_audited": int,
+            "state_mode": "light" | "heavy",
+            "elapsed_ms": int,
+        }
+    """
+    started = time.time()
+
+    if rubric_id not in client.list_rubrics():
+        return {
+            "error": f"unknown rubric_id '{rubric_id}'",
+            "available": client.list_rubrics(),
+        }
+
+    state = _build_heavy_state(ctx, include_masking=include_masking) if heavy else _build_light_state(ctx)
+    verdict = client.evaluate(rubric_id, state)
+
+    elapsed_ms = int((time.time() - started) * 1000)
+    response = {
+        **verdict,
+        "track_count_audited": len(state["tracks"]),
+        "state_mode": "heavy" if heavy else "light",
+        "elapsed_ms": elapsed_ms,
+    }
+    if include_brief:
+        response["revision_brief"] = iterator.format_revision_brief(verdict)
+    return response
+
+
+@mcp.tool()
+def grader_evaluate_all(
+    ctx: Context,
+    heavy: bool = True,
+    include_brief: bool = True,
+    include_masking: bool = True,
+) -> dict:
+    """Run ALL rubrics against the current session in one call.
+
+    Builds session state once and evaluates every registered rubric
+    against it. ~5× cheaper than calling `grader_evaluate` per rubric
+    because state-fetching is the dominant cost.
+
+    Default `heavy=True` — assumes a full audit. Pass `heavy=False`
+    for a fast §1/§7.3-only sweep.
+
+    Args:
+        heavy: When True (default), uses heavy state. When False, only
+            §1 default_preset_check and §7.3 layer_accumulation produce
+            useful verdicts; the others return n/a.
+        include_brief: Attach per-rubric revision_brief markdown.
+        include_masking: Include session-level masking report (heavy only).
+
+    Returns:
+        {
+            "rubrics": {
+                "<rubric_id>": {<verdict + brief>},
+                ...
+            },
+            "any_failed": bool,             # True if any rubric verdict is fail
+            "any_advisory": bool,           # True if any rubric has warns
+            "track_count_audited": int,
+            "state_mode": "light" | "heavy",
+            "elapsed_ms": int,
+            "combined_brief": str,          # merged across rubrics
+        }
+    """
+    started = time.time()
+    state = _build_heavy_state(ctx, include_masking=include_masking) if heavy else _build_light_state(ctx)
+
+    results: dict[str, Any] = {}
+    any_failed = False
+    any_advisory = False
+    brief_parts: list[str] = []
+
+    for rubric_id in client.list_rubrics():
+        verdict = client.evaluate(rubric_id, state)
+        if not verdict["passed"]:
+            any_failed = True
+        if any(c["severity"] == "warn" for c in verdict["criteria"]):
+            any_advisory = True
+
+        entry: dict[str, Any] = dict(verdict)
+        if include_brief:
+            brief = iterator.format_revision_brief(verdict)
+            entry["revision_brief"] = brief
+            if brief:
+                brief_parts.append(brief)
+        results[rubric_id] = entry
+
+    elapsed_ms = int((time.time() - started) * 1000)
+    response: dict[str, Any] = {
+        "rubrics": results,
+        "any_failed": any_failed,
+        "any_advisory": any_advisory,
+        "track_count_audited": len(state["tracks"]),
+        "state_mode": "heavy" if heavy else "light",
+        "elapsed_ms": elapsed_ms,
+    }
+    if include_brief:
+        response["combined_brief"] = "\n\n---\n\n".join(brief_parts) if brief_parts else ""
+    return response

package/mcp_server/m4l_bridge.py

@@ -1014,6 +1014,11 @@ class M4LBridge:
                 while len(s_bytes) % 4 != 0:
                     s_bytes += b'\x00'
                 arg_data += s_bytes
+            else:
+                raise TypeError(
+                    "OSC argument for %s must be int, float, or str, got %s"
+                    % (address, type(arg).__name__)
+                )
 
         tag_bytes = type_tags.encode('ascii') + b'\x00'
         while len(tag_bytes) % 4 != 0:

package/mcp_server/runtime/execution_router.py

@@ -36,7 +36,10 @@ from .remote_commands import BRIDGE_COMMANDS, REMOTE_COMMANDS
 MCP_TOOLS: frozenset[str] = frozenset({
     "apply_automation_shape",
     "apply_gesture_template",
+    "analyze_sample",
+    "analyze_synth_patch",
     "analyze_mix",
+    "get_masking_report",
     "get_master_spectrum",
     "get_emotional_arc",
     "get_motif_graph",
@@ -92,7 +95,10 @@ READ_ONLY_TOOLS: frozenset[str] = frozenset({
     "get_cue_points",
     "get_rack_chains",
     "get_clip_automation",
+    "analyze_sample",
+    "analyze_synth_patch",
     "analyze_mix",
+    "get_masking_report",
     "get_emotional_arc",
     "get_motif_graph",
     "get_session_diagnostics",

package/mcp_server/runtime/mcp_dispatch.py

@@ -60,11 +60,26 @@ async def _apply_gesture_template(params: dict, ctx: Any = None) -> dict:
     return await _call(apply_gesture_template, ctx, params)
 
 
+async def _analyze_sample(params: dict, ctx: Any = None) -> dict:
+    from ..sample_engine.tools import analyze_sample
+    return await _call(analyze_sample, ctx, params)
+
+
+async def _analyze_synth_patch(params: dict, ctx: Any = None) -> dict:
+    from ..synthesis_brain.tools import analyze_synth_patch
+    return await _call(analyze_synth_patch, ctx, params)
+
+
 async def _analyze_mix(params: dict, ctx: Any = None) -> dict:
     from ..mix_engine.tools import analyze_mix
     return await _call(analyze_mix, ctx, params)
 
 
+async def _get_masking_report(params: dict, ctx: Any = None) -> dict:
+    from ..mix_engine.tools import get_masking_report
+    return await _call(get_masking_report, ctx, params)
+
+
 async def _get_master_spectrum(params: dict, ctx: Any = None) -> dict:
     from ..tools.analyzer import get_master_spectrum
     return await _call(get_master_spectrum, ctx, params)
@@ -151,7 +166,10 @@ def build_mcp_dispatch_registry() -> dict[str, Callable]:
         "load_sample_to_simpler": _load_sample_to_simpler,
         "apply_automation_shape": _apply_automation_shape,
         "apply_gesture_template": _apply_gesture_template,
+        "analyze_sample": _analyze_sample,
+        "analyze_synth_patch": _analyze_synth_patch,
         "analyze_mix": _analyze_mix,
+        "get_masking_report": _get_masking_report,
         "get_master_spectrum": _get_master_spectrum,
         "get_emotional_arc": _get_emotional_arc,
         "get_motif_graph": _get_motif_graph,

package/mcp_server/runtime/remote_commands.py

@@ -83,6 +83,8 @@ REMOTE_COMMANDS: frozenset[str] = frozenset({
     "capture_midi", "start_recording", "stop_recording",
     "get_cue_points", "jump_to_cue", "toggle_cue_point",
     "back_to_arranger", "force_arrangement",
+    "arrangement_automation_via_session_record_start",
+    "arrangement_automation_via_session_record_complete",
     # scales — Song + per-clip scale awareness (Live 12.0+)
     "get_song_scale", "set_song_scale", "set_song_scale_mode",
     "list_available_scales",

package/mcp_server/server.py

@@ -309,6 +309,7 @@ from .composer import tools as composer_tools                  # noqa: F401, E40
 from .synthesis_brain import tools as synthesis_brain_tools    # noqa: F401, E402
 from .user_corpus import tools as user_corpus_tools            # noqa: F401, E402
 from .audit import tools as audit_tools                        # noqa: F401, E402
+from .grader import tools as grader_tools                      # noqa: F401, E402
 from .tools import diagnostics   # noqa: F401, E402
 from .tools import miditool       # noqa: F401, E402
 
@@ -354,14 +355,14 @@ def _coerce_schema_property(prop: dict) -> None:
 def _get_all_tools():
     """Get all registered tools — defends against FastMCP internal drift.
 
-    FastMCP's public API doesn't expose the registry as of 3.2.x (see
+    FastMCP's public API doesn't expose the registry as of 3.3.x (see
     docs/FASTMCP_UPSTREAM_FR.md). Until it does, we probe known internal
     attribute paths. Each probe fires in try/except so a structural
-    rearrangement (e.g. ``_components`` renamed under 3.3+) falls through
+    rearrangement (e.g. ``_components`` renamed under 3.4+) falls through
     to the next path rather than exploding.
 
     WARNING: Accesses FastMCP private internals. Pinned to
-    fastmcp>=3.0.0,<3.3.0 in requirements.txt. The startup self-test
+    fastmcp>=3.3.1,<3.4.0 in requirements.txt. The startup self-test
     (_assert_tool_registry_accessible) will fail loudly if every probe
     returns empty — better than silently returning [] and disabling
     schema coercion.
@@ -369,14 +370,18 @@ def _get_all_tools():
     probes = [
         # FastMCP 0.x: mcp._tool_manager._tools (dict of name -> Tool)
         ("_tool_manager._tools", lambda: list(mcp._tool_manager._tools.values())),
-        # FastMCP 3.0–3.2: mcp._local_provider._components
+        # FastMCP 3.0–3.3: mcp._local_provider._components
+        # (verified 2026-05-21 against fastmcp 3.3.1 — still the active path)
         (
             "_local_provider._components",
             lambda: list(mcp._local_provider._components.values()),
         ),
-        # FastMCP 3.3+ speculative: mcp._local_provider._tools (anticipated
-        # rename based on naming conventions in other providers). Kept here
-        # so a future bump surfaces a partial match rather than a full miss.
+        # FastMCP 3.4+ speculative: mcp._local_provider._tools (anticipated
+        # rename based on naming conventions in other providers). Verified
+        # 2026-05-21 against fastmcp 3.3.1 — the rename did NOT happen in
+        # 3.3.x; ``_local_provider._components`` remains the live registry.
+        # Kept here so a future bump that DOES rename surfaces a partial
+        # match rather than a full miss.
         (
             "_local_provider._tools",
             lambda: list(mcp._local_provider._tools.values()),

package/mcp_server/tools/browser.py

@@ -30,6 +30,64 @@ def _validate_track_index(track_index: int):
         )
 
 
+def _atlas_preflight_for_load(device_name: str) -> Optional[dict]:
+    """Atlas-aware preflight check for a freshly-loaded device.
+
+    Returns a dict with `self_contained: false` warning when the loaded
+    device is in the enriched atlas AND declares it requires a source
+    sample / capture. Returns None for self-contained devices, devices
+    not in the atlas, or atlas lookup failures.
+
+    Added 2026-05-08 after a Granulator III load silently produced no
+    audio: instrument loaded fine, grain params programmed, BUT no sample
+    in the source slot → silence. The atlas YAML for Granulator III has
+    `self_contained: false` and signature_techniques all start with "Load
+    a sample → ..." but neither was surfaced at load time. This preflight
+    closes that gap by reading the atlas immediately after load and
+    surfacing the requirement in the load response.
+    """
+    if not device_name:
+        return None
+    try:
+        from ..atlas import get_atlas
+        atlas = get_atlas()
+    except Exception:
+        return None
+    if atlas is None:
+        return None
+    try:
+        entry = atlas.lookup(device_name)
+    except Exception:
+        return None
+    if not entry or not entry.get("enriched"):
+        return None
+    if entry.get("self_contained") is not False:
+        return None  # self-contained or unspecified — no warning needed
+
+    techniques = entry.get("signature_techniques") or []
+    first_hint = ""
+    if techniques and isinstance(techniques[0], dict):
+        first_hint = (
+            techniques[0].get("description")
+            or techniques[0].get("name")
+            or ""
+        )
+
+    return {
+        "self_contained": False,
+        "device_id": entry.get("id"),
+        "warning": (
+            f"{device_name} is not self-contained — it requires a source "
+            "sample or real-time audio capture to produce sound. The "
+            "instrument is loaded but will be silent until a sample is "
+            "added. Either drag audio onto its waveform display, OR load "
+            "a Sounds preset chain via search_browser(path='sounds', "
+            f"name_filter='{device_name}') that ships with a sample baked in."
+        ),
+        "first_technique_hint": str(first_hint).strip()[:240],
+    }
+
+
 @mcp.tool()
 def get_browser_tree(ctx: Context, category_type: str = "all") -> dict:
     """Get an overview of browser categories and their children."""
@@ -297,6 +355,16 @@ def load_browser_item(
         except Exception:
             pass
 
+    # Layer 0 — atlas-aware preflight. Surface a follow-up hint when the
+    # loaded device declares self_contained=false in its atlas enrichment
+    # YAML (granular samplers, sample players). Prevents the silent-
+    # Granulator-III failure mode where the instrument loads, params get
+    # programmed, but no audio source has been added.
+    if device_name_loaded:
+        preflight = _atlas_preflight_for_load(device_name_loaded)
+        if preflight is not None:
+            result["atlas_preflight"] = preflight
+
     # Layer 1 — Simpler role-aware defaults
     if role and device_index_resolved is not None and "Simpler" in device_class:
         applied = []

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "livepilot",
-  "version": "1.25.0",
+  "version": "1.26.1",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 \u2014 462 tools, 55 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",
+  "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",
   "license": "BSL-1.1",
   "type": "commonjs",
   "bin": {
-    "livepilot": "./bin/livepilot.js"
+    "livepilot": "bin/livepilot.js"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/dreamrec/LivePilot"
+    "url": "git+https://github.com/dreamrec/LivePilot.git"
   },
   "homepage": "https://github.com/dreamrec/LivePilot",
   "bugs": {
@@ -47,6 +47,7 @@
   "files": [
     "bin/**/*.js",
     "installer/**/*.js",
+    "livepilot/**",
     "mcp_server/**/*.py",
     "mcp_server/**/*.json",
     "mcp_server/**/*.yaml",
@@ -56,6 +57,9 @@
     "m4l_device/LivePilot_Analyzer.amxd",
     "m4l_device/LivePilot_Analyzer.adv",
     "m4l_device/livepilot_bridge.js",
+    "m4l_device/LivePilot_Elektron.amxd",
+    "m4l_device/LivePilot_Elektron.maxpat",
+    "m4l_device/livepilot_elektron_bridge.js",
     "m4l_device/BUILD_GUIDE.md",
     "requirements.txt",
     "README.md",
@@ -64,6 +68,17 @@
     "server.json",
     "!**/__pycache__/**",
     "!**/*.pyc",
-    "!**/.DS_Store"
+    "!**/.DS_Store",
+    "!livepilot/skills/livepilot-core/references/device-atlas/synths-m4l.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/plugins-synths.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/utility-and-workflow.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/samples-and-irs.md",
+    "!livepilot/skills/livepilot-core/references/device-atlas/presets-by-vibe.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-vendor/**",
+    "!livepilot/skills/livepilot-devices/references/m4l-depth-pass-findings.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-depth-pass-resume.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-library-deep.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-master-reference.md",
+    "!livepilot/skills/livepilot-devices/references/m4l-technique-map.md"
   ]
 }

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.25.0"
+__version__ = "1.26.1"
 
 from _Framework.ControlSurface import ControlSurface
 from . import router