livepilot 1.10.0 → 1.10.2

package/mcp_server/semantic_moves/tools.py

@@ -27,13 +27,15 @@ def list_semantic_moves(
     Semantic moves express WHAT to achieve musically, not HOW parametrically.
     Each move compiles into a sequence of existing deterministic tools.
 
-    domain: filter by family (mix, arrangement, transition, sound_design, performance)
+    domain: filter by family (e.g. mix, arrangement, transition, sound_design, sample, performance)
     style: filter by genre/style (reserved for future use)
 
     Returns: list of moves with move_id, family, intent, targets, risk_level.
     """
     moves = registry.list_moves(domain=domain, style=style)
-    return {"moves": moves, "count": len(moves), "available_domains": ["mix", "arrangement"]}
+    all_moves = registry.list_moves()
+    domains = sorted({m.get("family", "") for m in all_moves if m.get("family")})
+    return {"moves": moves, "count": len(moves), "available_domains": domains}
 
 
 @mcp.tool()
@@ -43,9 +45,13 @@ def preview_semantic_move(
 ) -> dict:
     """Preview what a semantic move will do before applying it.
 
-    Returns the full compile plan (tool sequence), verification plan,
-    targets, protection constraints, and risk level. Use this to understand
-    the impact before committing.
+    Returns the static plan_template + verification_plans, PLUS an additive
+    compiled_plan field built by compiling the move against a lightweight
+    kernel of the current session. Use compiled_plan to inspect the concrete
+    tool calls the move would emit right now; use plan_template to understand
+    the move's shape independent of session state.
+
+    Existing callers reading plan_template are unaffected by the addition.
     """
     move = registry.get_move(move_id)
     if not move:
@@ -55,7 +61,46 @@ def preview_semantic_move(
             "available_moves": available,
         }
 
-    return move.to_full_dict()
+    result = move.to_full_dict()
+
+    # Additive: compile against a lightweight kernel so callers get an
+    # executable representation alongside the static plan_template.
+    try:
+        from ..runtime.session_kernel import build_session_kernel
+        from ..runtime.capability_state import build_capability_state
+        from . import compiler as move_compiler
+
+        ableton = None
+        if hasattr(ctx, "lifespan_context"):
+            ableton = ctx.lifespan_context.get("ableton")
+
+        session_info: dict = {}
+        if ableton is not None:
+            try:
+                info = ableton.send_command("get_session_info")
+                if isinstance(info, dict):
+                    session_info = info
+            except Exception:
+                session_info = {}
+
+        state = build_capability_state(
+            session_ok=bool(session_info),
+            analyzer_ok=False,
+            memory_ok=True,
+        )
+        kernel = build_session_kernel(
+            session_info=session_info,
+            capability_state=state.to_dict(),
+        )
+        plan = move_compiler.compile(move, kernel.to_dict())
+        result["compiled_plan"] = plan.to_dict()
+        result["compiled_plan_executable"] = bool(plan.executable)
+    except Exception as e:
+        result["compiled_plan"] = None
+        result["compiled_plan_executable"] = False
+        result["compiled_plan_error"] = str(e)
+
+    return result
 
 
 @mcp.tool()
@@ -124,7 +169,7 @@ def propose_next_best_move(
 
 
 @mcp.tool()
-def apply_semantic_move(
+async def apply_semantic_move(
     ctx: Context,
     move_id: str,
     mode: str = "improve",
@@ -177,14 +222,22 @@ def apply_semantic_move(
         result["note"] = "Awaiting approval — present the plan to the user, then execute steps individually"
         return result
 
-    # explore mode — execute through unified router
-    from ..runtime.execution_router import execute_plan_steps
+    # explore mode — execute through the async router
+    from ..runtime.execution_router import execute_plan_steps_async
 
     step_dicts = [
         {"tool": step.tool, "params": step.params, "description": step.description}
         for step in plan.steps
     ]
-    exec_results = execute_plan_steps(step_dicts, ableton=ableton, ctx=ctx)
+    bridge = ctx.lifespan_context.get("m4l")
+    mcp_registry = ctx.lifespan_context.get("mcp_dispatch", {})
+    exec_results = await execute_plan_steps_async(
+        step_dicts,
+        ableton=ableton,
+        bridge=bridge,
+        mcp_registry=mcp_registry,
+        ctx=ctx,
+    )
 
     executed_steps = []
     for i, er in enumerate(exec_results):

package/mcp_server/semantic_moves/transition_moves.py

@@ -10,7 +10,7 @@ INCREASE_FORWARD_MOTION = SemanticMove(
     targets={"motion": 0.5, "energy": 0.3, "tension": 0.2},
     protect={"clarity": 0.6},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_automation_shape", "params": {"curve_type": "exponential", "description": "Rising filter cutoff over 4 bars"}, "description": "Rising filter sweep", "backend": "mcp_tool"},
         {"tool": "set_track_volume", "params": {"description": "Push rhythm elements +5-8%"}, "description": "Push rhythm forward", "backend": "remote_command"},
         {"tool": "apply_automation_shape", "params": {"curve_type": "linear", "description": "Rising reverb send for anticipation"}, "description": "Build reverb wash", "backend": "mcp_tool"},
@@ -27,7 +27,7 @@ OPEN_CHORUS = SemanticMove(
     targets={"energy": 0.4, "width": 0.3, "contrast": 0.3},
     protect={"clarity": 0.6, "cohesion": 0.5},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Push all melodic tracks +10-15%"}, "description": "Push chorus energy", "backend": "remote_command"},
         {"tool": "set_track_pan", "params": {"description": "Widen stereo field on chords/pads"}, "description": "Widen stereo", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Increase reverb/delay sends for spaciousness"}, "description": "Add space", "backend": "remote_command"},
@@ -45,7 +45,7 @@ CREATE_BREAKDOWN = SemanticMove(
     targets={"contrast": 0.5, "depth": 0.3, "clarity": 0.2},
     protect={"cohesion": 0.5},
     risk_level="medium",
-    compile_plan=[
+    plan_template=[
         {"tool": "set_track_volume", "params": {"description": "Pull drums to 20-30%"}, "description": "Strip drums", "backend": "remote_command"},
         {"tool": "set_track_volume", "params": {"description": "Pull bass to 30-40%"}, "description": "Reduce bass", "backend": "remote_command"},
         {"tool": "set_track_send", "params": {"description": "Increase reverb send on remaining elements"}, "description": "Add reverb depth", "backend": "remote_command"},
@@ -62,7 +62,7 @@ BRIDGE_SECTIONS = SemanticMove(
     targets={"motion": 0.4, "contrast": 0.3, "cohesion": 0.3},
     protect={"clarity": 0.6},
     risk_level="low",
-    compile_plan=[
+    plan_template=[
         {"tool": "apply_automation_shape", "params": {"curve_type": "cosine", "description": "Gentle filter sweep across bridge"}, "description": "Bridge filter motion", "backend": "mcp_tool"},
         {"tool": "set_track_volume", "params": {"description": "Gentle volume crossfade between section elements"}, "description": "Crossfade elements", "backend": "remote_command"},
     ],

package/mcp_server/server.py

@@ -76,11 +76,24 @@ async def _warm_analyzer_bridge(
 
 @asynccontextmanager
 async def lifespan(server):
-    """Create and yield the shared AbletonConnection + M4L bridge."""
+    """Create and yield the shared AbletonConnection + M4L bridge + registries."""
+    from .runtime.mcp_dispatch import build_mcp_dispatch_registry
+    from .splice_client.client import SpliceGRPCClient
+
     ableton = AbletonConnection()
     spectral = SpectralCache()
     receiver = SpectralReceiver(spectral)
     m4l = M4LBridge(spectral, receiver)
+    mcp_dispatch = build_mcp_dispatch_registry()
+
+    # Splice gRPC client — graceful degradation if Splice desktop isn't
+    # running or grpcio isn't installed. .connected will be False in that
+    # case and sample_resolver treats it as "no splice hits".
+    splice_client = SpliceGRPCClient()
+    try:
+        await splice_client.connect()
+    except Exception:
+        pass  # client remains in disconnected state
 
     # Start UDP listener for incoming M4L spectral data (port 9880)
     loop = asyncio.get_running_loop()
@@ -121,12 +134,18 @@ async def lifespan(server):
             "spectral": spectral,
             "m4l": m4l,
             "_bridge_state": bridge_state,
+            "mcp_dispatch": mcp_dispatch,
+            "splice_client": splice_client,
         }
     finally:
         if bridge_state["transport"]:
             bridge_state["transport"].close()
         m4l.close()
         ableton.disconnect()
+        try:
+            await splice_client.disconnect()
+        except Exception:
+            pass
 
 
 mcp = FastMCP("LivePilot", lifespan=lifespan)

package/mcp_server/session_continuity/tracker.py

@@ -210,7 +210,10 @@ def rank_by_taste_and_identity(
         identity_effect = candidate.get("identity_effect", "preserves")
 
         # Taste score — how well does this fit cross-session preferences?
-        boldness_pref = taste_graph.get("transition_boldness", 0.5)
+        # Routed through the canonical accessor so dimension_weights.transition_boldness
+        # is honored. Previously read the top-level key directly and always got 0.5.
+        from ..memory.taste_accessors import get_dimension_pref
+        boldness_pref = get_dimension_pref(taste_graph, "transition_boldness", default=0.5)
         taste_score = 1.0 - abs(novelty - boldness_pref) * 0.8
         taste_score = round(max(0.0, min(1.0, taste_score)), 3)
 

package/mcp_server/tools/_conductor.py

@@ -110,6 +110,12 @@ _ROUTING_PATTERNS: list[tuple[str, str, str, str, list[str]]] = [
     # Research requests
     (r"research|how.?to|technique|tutorial|learn", "research", "research", "research_technique", []),
     (r"style.?tactic|production.?style|genre.?approach", "research", "research", "get_style_tactics", []),
+
+    # Sample requests
+    (r"sample|splice|loop|chop|flip|break(?:beat)?|one.?shot", "sample_engine", "sample", "search_samples", ["analyze_sample", "plan_sample_workflow"]),
+    (r"slice|transient.?hit|slice.?mode", "sample_engine", "sample", "plan_slice_workflow", ["search_samples"]),
+    (r"vocal.?sample|foley|field.?record|found.?sound", "sample_engine", "sample", "search_samples", ["analyze_sample"]),
+    (r"texture.?sample|ambient.?sample|atmo.?sample", "sample_engine", "sample", "search_samples", ["suggest_sample_technique"]),
 ]
 
 
@@ -164,6 +170,16 @@ def _infer_workflow_mode(request_lower: str) -> str:
     if re.search(r"fix|quick|just|only|undo|revert|simple", request_lower):
         return "quick_fix"
 
+    # Slice workflow
+    if re.search(r"slice|chop|transient.?hit", request_lower):
+        return "slice_workflow"
+
+    # Sample workflows
+    if re.search(r"sample|splice|foley|found.?sound|one.?shot|break(?:beat)?|flip|loop", request_lower):
+        if re.search(r"arrange|section|verse|chorus|drop|bridge|hook", request_lower):
+            return "sample_plus_arrangement"
+        return "sample_discovery"
+
     # Agentic loop keywords (full autonomous)
     if re.search(r"autonomous|auto|full|everything|deep|polish|finish", request_lower):
         return "agentic_loop"

package/mcp_server/tools/_planner_engine.py

@@ -164,6 +164,8 @@ class SectionPlan:
     tracks_entering: list[int]  # new elements introduced in this section
     tracks_exiting: list[int]  # elements removed in this section
 
+    sample_hints: list[str] = field(default_factory=list)
+
     def length_bars(self) -> int:
         return self.end_bar - self.start_bar
 
@@ -196,6 +198,28 @@ class ArrangementPlan:
         }
 
 
+# ── Section Sample Hints ─────────────────────────────────────────────
+
+_SECTION_SAMPLE_DEFAULTS: dict[str, list[str]] = {
+    "intro": ["texture_bed", "fill_one_shot"],
+    "verse": ["texture_bed", "fill_one_shot"],
+    "pre_chorus": ["transition_fx", "texture_bed"],
+    "chorus": ["hook_sample", "break_layer", "fill_one_shot"],
+    "drop": ["hook_sample", "break_layer", "fill_one_shot"],
+    "build": ["transition_fx", "texture_bed"],
+    "bridge": ["texture_bed", "transition_fx"],
+    "breakdown": ["texture_bed"],
+    "outro": ["texture_bed", "fill_one_shot"],
+}
+
+
+def add_sample_hints(plan: "ArrangementPlan") -> None:
+    """Populate sample_hints on each section based on section type."""
+    for section in plan.sections:
+        section_key = section.section_type.value.lower()
+        section.sample_hints = _SECTION_SAMPLE_DEFAULTS.get(section_key, ["texture_bed"])
+
+
 # ── Core Planner ─────────────────────────────────────────────────────
 
 def plan_arrangement_from_loop(

package/mcp_server/tools/analyzer.py

@@ -381,6 +381,8 @@ async def load_sample_to_simpler(
         return {"error": "Sample replacement failed after bootstrap"}
 
     result["method"] = "bootstrap_and_replace"
+    result["device_index"] = actual_device_index  # additive — for step-result binding
+    result["track_index"] = track_index
     return result
 
 

package/mcp_server/tools/planner.py

@@ -88,6 +88,9 @@ def plan_arrangement(
         style=style,
     )
 
+    # Add section-level sample role hints
+    planner_engine.add_sample_hints(plan)
+
     result = plan.to_dict()
     result["loop_identity"] = loop_identity.to_dict()
     result["available_styles"] = sorted(planner_engine.VALID_STYLES)

package/mcp_server/wonder_mode/engine.py

@@ -25,11 +25,11 @@ def discover_moves(
     """Find semantic moves relevant to the request.
 
     Uses keyword scoring + optional taste reranking + constraint filtering.
-    Returns full move dicts including compile_plan (via registry.get_move).
+    Returns full move dicts including plan_template (via registry.get_move).
     """
     from ..semantic_moves import registry
 
-    all_moves = registry.list_moves()  # returns to_dict() — no compile_plan
+    all_moves = registry.list_moves()  # returns to_dict() — no plan_template
     if not all_moves:
         return []
 
@@ -77,7 +77,7 @@ def discover_moves(
 
     scored.sort(key=lambda x: -x[1])
 
-    # Enrich with full compile_plan via get_move()
+    # Enrich with full plan_template via get_move()
     result = []
     for move_dict, score in scored:
         full_move = registry.get_move(move_dict["move_id"])
@@ -98,7 +98,7 @@ def discover_moves(
             for move in result:
                 plan = {"steps": [
                     {"action": step.get("tool", ""), **step}
-                    for step in (move.get("compile_plan") or [])
+                    for step in (move.get("plan_template") or [])
                 ]}
                 validation = validate_plan_against_constraints(plan, active_constraints)
                 if validation["valid"]:
@@ -137,9 +137,9 @@ def _with_envelope(move: dict, tier: str) -> dict:
 # ── Distinctness selection ───────────────────────────────────────
 
 
-def _compile_plan_shape(move: dict) -> frozenset[str]:
-    """Extract the set of tool names from a move's compile_plan."""
-    plan = move.get("compile_plan") or []
+def _plan_template_shape(move: dict) -> frozenset[str]:
+    """Extract the set of tool names from a move's plan_template."""
+    plan = move.get("plan_template") or []
     return frozenset(step.get("tool", "") for step in plan if step.get("tool"))
 
 
@@ -147,7 +147,7 @@ def select_distinct_variants(scored_moves: list[dict]) -> list[dict]:
     """Select genuinely distinct moves for variant generation.
 
     Each selected move must differ from all previously selected moves by
-    at least one of: move_id, family, or compile_plan shape.
+    at least one of: move_id, family, or plan_template shape.
     Returns 0-3 moves.
     """
     if not scored_moves:
@@ -160,7 +160,7 @@ def select_distinct_variants(scored_moves: list[dict]) -> list[dict]:
     for move in scored_moves:
         mid = move.get("move_id", "")
         family = move.get("family", "")
-        shape = _compile_plan_shape(move)
+        shape = _plan_template_shape(move)
 
         # Skip duplicate move_ids
         if mid in used_ids:
@@ -190,14 +190,45 @@ _NOVELTY_LEVELS = {"safe": 0.25, "strong": 0.55, "unexpected": 0.85}
 _RISK_TO_EFFECT = {"low": "preserves", "medium": "evolves", "high": "contrasts"}
 
 
+def _compile_variant_plan(move_dict: dict, kernel: dict | None) -> dict | None:
+    """Compile a move through the semantic compiler if possible.
+
+    Returns CompiledPlan.to_dict() or None if no compiler is registered.
+    """
+    if kernel is None:
+        return None
+
+    move_id = move_dict.get("move_id", "")
+    from ..semantic_moves.compiler import compile as sem_compile, _COMPILERS
+    from ..semantic_moves import registry
+
+    if move_id not in _COMPILERS:
+        return None
+
+    move_obj = registry.get_move(move_id)
+    if move_obj is None:
+        return None
+
+    try:
+        plan = sem_compile(move_obj, kernel)
+        return plan.to_dict()
+    except Exception:
+        return None
+
+
 def build_variant(
     label: str,
     move_dict: dict,
     song_brain: Optional[dict] = None,
     novelty_level: float = 0.5,
     variant_id: str = "",
+    kernel: dict | None = None,
 ) -> dict:
-    """Build a variant dict from a real move + SongBrain context."""
+    """Build a variant dict from a real move + SongBrain context.
+
+    If kernel is provided, compiles the move through the semantic compiler
+    for an executable plan. Otherwise falls back to plan_template metadata.
+    """
     song_brain = song_brain or {}
     targets = move_dict.get("targets", {})
     protect = move_dict.get("protect", {})
@@ -226,6 +257,10 @@ def build_variant(
     if sacred and identity_effect == "preserves":
         why += f". Preserves {sacred[0].get('description', 'sacred elements')}"
 
+    # Compile through semantic compiler if kernel available
+    compiled = _compile_variant_plan(move_dict, kernel)
+    analytical = compiled is None
+
     return {
         "variant_id": variant_id,
         "label": label,
@@ -239,11 +274,11 @@ def build_variant(
         "novelty_level": novelty_level,
         "taste_fit": 0.5,
         "targets_snapshot": dict(targets),
-        "compiled_plan": move_dict.get("compile_plan"),
+        "compiled_plan": compiled,
         "score": 0.0,
         "rank": 0,
         "score_breakdown": {},
-        "analytical_only": False,
+        "analytical_only": analytical,
         "distinctness_reason": "",
     }
 
@@ -479,6 +514,8 @@ def generate_wonder_variants(
     song_brain: dict | None = None,
     taste_graph: object = None,
     active_constraints: object = None,
+    session_info: dict | None = None,
+    sample_context: dict | None = None,
 ) -> dict:
     """Full wonder mode pipeline: discover -> select distinct -> build -> taste -> rank."""
     song_brain = song_brain or {}
@@ -495,6 +532,14 @@ def generate_wonder_variants(
     # Load corpus intelligence for variant enrichment
     corpus_hints = _get_corpus_hints(request_text, diagnosis)
 
+    # Build kernel for variant compilation
+    kernel = {
+        "session_info": session_info or {},
+        "mode": "improve",
+    }
+    if sample_context:
+        kernel.update(sample_context)
+
     # Build executable variants from distinct moves
     for i, move in enumerate(distinct):
         label = labels[i]
@@ -505,6 +550,7 @@ def generate_wonder_variants(
             song_brain=song_brain,
             novelty_level=_NOVELTY_LEVELS.get(label, 0.5),
             variant_id=f"{set_prefix}_{label}",
+            kernel=kernel,
         )
         if taste_graph is not None:
             # Score taste on envelope-adjusted move for consistency with targets_snapshot
@@ -567,7 +613,7 @@ def _explain_distinctness(move: dict, all_moves: list[dict], index: int) -> str:
 
     if family not in other_families:
         return f"Different family: {family}"
-    shape = _compile_plan_shape(move)
+    shape = _plan_template_shape(move)
     return f"Different approach: {', '.join(sorted(shape))}"
 
 

package/mcp_server/wonder_mode/tools.py

@@ -126,14 +126,46 @@ def enter_wonder_mode(
         action_ledger=action_ledger,
     )
 
+    # 1b. If diagnosis includes sample domains, search for candidates
+    sample_context = {}
+    diag_dict = diagnosis.to_dict()
+    candidate_domains = diag_dict.get("candidate_domains") or []
+    if "sample" in candidate_domains:
+        try:
+            from ..sample_engine.tools import get_sample_opportunities, search_samples
+            opportunities = get_sample_opportunities(ctx)
+            if opportunities.get("opportunities"):
+                opp = opportunities["opportunities"][0]
+                query = opp.get("search_query", opp.get("description", "sample"))
+                results = search_samples(ctx, query=query, max_results=3)
+                candidates = results.get("results", [])
+                if candidates:
+                    best = candidates[0]
+                    sample_context["sample_file_path"] = best.get("file_path", "")
+                    sample_context["sample_name"] = best.get("name", "")
+                    sample_context["material_type"] = best.get("material_type", "")
+        except Exception:
+            pass  # Graceful degradation — analytical variants still work
+
+    # 1c. Get session info for kernel
+    session_info = {}
+    try:
+        ableton = ctx.lifespan_context.get("ableton")
+        if ableton:
+            session_info = ableton.send_command("get_session_info", {})
+    except Exception:
+        pass
+
     # 2. Generate variants
     result = engine.generate_wonder_variants(
         request_text=request_text,
-        diagnosis=diagnosis.to_dict(),
+        diagnosis=diag_dict,
         kernel_id=kernel_id,
         song_brain=song_brain,
         taste_graph=taste_graph,
         active_constraints=active_constraints,
+        session_info=session_info,
+        sample_context=sample_context,
     )
 
     # 3. Create WonderSession (unique per invocation, not deterministic)

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "livepilot",
-  "version": "1.10.0",
+  "version": "1.10.2",
   "mcpName": "io.github.dreamrec/livepilot",
-  "description": "Agentic production system for Ableton Live 12 — 316 tools, 43 domains, device atlas, spectral perception, technique memory, neo-Riemannian harmony, Euclidean rhythm, species counterpoint, MIDI I/O",
+  "description": "Agentic production system for Ableton Live 12 — 317 tools, 43 domains. Device atlas (1305 devices), sample engine (Splice + browser + filesystem), auto-composition, spectral perception, technique memory, creative intelligence (12 engines)",
   "author": "Pilot Studio",
-  "license": "MIT",
+  "license": "BSL-1.1",
   "type": "commonjs",
   "bin": {
     "livepilot": "./bin/livepilot.js"
@@ -18,10 +18,6 @@
     "url": "https://github.com/dreamrec/LivePilot/issues"
   },
   "funding": [
-    {
-      "type": "patreon",
-      "url": "https://www.patreon.com/c/dreamrec"
-    },
     {
       "type": "github",
       "url": "https://github.com/sponsors/dreamrec"
@@ -39,7 +35,11 @@
     "ai",
     "sound-design",
     "mixing",
-    "arrangement"
+    "arrangement",
+    "splice",
+    "sample-engine",
+    "auto-composition",
+    "device-atlas"
   ],
   "engines": {
     "node": ">=18.0.0"

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.10.0"
+__version__ = "1.10.2"
 
 from _Framework.ControlSurface import ControlSurface
 from .server import LivePilotServer

package/remote_script/LivePilot/devices.py

@@ -508,21 +508,31 @@ def insert_device(song, params):
                 device = chain.insert_device(canonical, position)
             else:
                 device = chain.insert_device(canonical)
+            container_devices = list(chain.devices)
         else:
             # Track-level insertion
             if position >= 0:
                 device = track.insert_device(canonical, position)
             else:
                 device = track.insert_device(canonical)
+            container_devices = list(track.devices)
     finally:
         song.end_undo_step()
 
+    # Resolve the index the newly-inserted device landed at so callers can
+    # bind later parameter/chain operations to it (composer plans rely on this).
+    try:
+        inserted_index = container_devices.index(device)
+    except ValueError:
+        inserted_index = len(container_devices) - 1
+
     # Read back the device info — use "loaded" key to match
     # the convention expected by _postflight_loaded_device on MCP side
     result = {
         "loaded": device.name,
         "class_name": device.class_name,
         "track_index": track_index,
+        "device_index": inserted_index,  # additive — for step-result binding
         "parameter_count": len(list(device.parameters)),
     }
     if position >= 0: