davinci-resolve-mcp 2.56.1 → 2.57.1

package/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 Release history for the DaVinci Resolve MCP Server. The latest release is summarized in the root README; older entries live here to keep the README focused.
 
+## What's New in v2.57.1
+
+Investigation outcome for community feature request #74 — no behavior change.
+
+- **Note** (issue #74) the DaVinci Resolve scripting API does not expose the
+  Source/Auto Track Selector, so there is no way to choose the destination track
+  when inserting Text+/titles/generators. Verified live on Resolve Studio 21.0.0:
+  no get/set for the selector exists; the `Insert*IntoTimeline` family takes no
+  `trackIndex` and always lands on V1; locking lower tracks makes the insert fail
+  rather than redirect; and titles/generators can't be relocated afterward (no
+  `MediaPoolItem`). Closed as won't-fix (API limitation).
+- **Documentation** recorded the limitation in the verified `api_truth` ledger
+  (query at runtime with `resolve_control api_truth "track"`) and in
+  `docs/reference/api-coverage.md`, with the supported alternative for
+  media-backed clips (`MediaPool.AppendToTimeline` clipInfo `trackIndex`, exposed
+  as `media_pool.append_to_timeline` `clip_infos`). Added a regression test.
+
+## What's New in v2.57.0
+
+Community feature requests #72 and #73.
+
+- **Added** OpenCode to the installer's supported MCP clients (issue #72). The
+  installer now writes/merges `~/.config/opencode/opencode.json` using OpenCode's
+  own schema (`type`/`enabled`, a combined `command` array, and an `environment`
+  block), and `--manual` prints a ready-to-paste OpenCode snippet.
+- **Added** `fusion_comp(action="add_fusion_mask", ...)` (issue #73): a one-call
+  Rectangle/Ellipse mask — adds the mask tool, sets its params (`corner_radius`,
+  `width`, `height`, `center`/`center_x`/`center_y`, etc., all 0..1), and
+  optionally wires it into a tool's mask input (`EffectMask` by default). Each
+  input is applied independently so one unsupported parameter never aborts the rest.
+- **Added** `fusion_comp(action="set_text_plus" / "get_text_plus", ...)` (issue
+  #73): read/write the text of a Fusion `Text+` tool or Fusion title template
+  (e.g. a "Deep" title), auto-finding the `Text+` tool when `tool_name` is
+  omitted. Complements `timeline(action="set_title_text")` for generator titles.
+- **Note** (issue #73) per-clip audio Stereo↔Mono conversion is not in
+  Blackmagic's scripting API and was not added. The supported surface is already
+  exposed: `timeline get_track_sub_type` (query channel format), `add_track` with
+  `audioType` (create mono/stereo tracks), `convert_to_stereo` (timeline-wide),
+  and `timeline_item get_source_audio_channel_mapping`.
+
 ## What's New in v2.56.1
 
 Final reliability batch from the exhaustive audit (Wave B + P2/P3 selections).

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.56.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.57.1-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
 [![npm](https://img.shields.io/npm/v/davinci-resolve-mcp.svg?label=npm&color=CB3837)](https://www.npmjs.com/package/davinci-resolve-mcp)
 [![API Coverage](https://img.shields.io/badge/API%20Coverage-100%25-brightgreen.svg)](docs/reference/api-coverage.md)
 [![Tools](https://img.shields.io/badge/MCP%20Tools-34%20(341%20full)-blue.svg)](#server-modes)
@@ -21,7 +21,7 @@ A local browser control panel ships with the server for inspecting Resolve state
 npx davinci-resolve-mcp setup
 ```
 
-Before connecting, open DaVinci Resolve Studio and set **Preferences > General > External scripting using** to **Local**. The npm launcher installs a managed copy under your user application-data directory, then runs the universal Python installer. The installer creates a virtual environment, detects Resolve paths, and can configure Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Zed, Continue, Cline, Roo Code, and JetBrains IDEs.
+Before connecting, open DaVinci Resolve Studio and set **Preferences > General > External scripting using** to **Local**. The npm launcher installs a managed copy under your user application-data directory, then runs the universal Python installer. The installer creates a virtual environment, detects Resolve paths, and can configure Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Zed, Continue, Cline, Roo Code, OpenCode, and JetBrains IDEs.
 
 For source installs:
 
@@ -168,3 +168,6 @@ Samuel Gursky (samgursky@gmail.com)
 
 - [@rgxdev](https://github.com/rgxdev) — configurable Media Pool inventory walk
   (exclude bins + inventory limit), [#69](https://github.com/samuelgursky/davinci-resolve-mcp/pull/69) (v2.53.0)
+- [@swayll](https://github.com/swayll) — Source Track Selector investigation
+  ([#74](https://github.com/samuelgursky/davinci-resolve-mcp/issues/74)); confirmed
+  + documented API limitation (v2.57.1)

package/docs/SKILL.md

@@ -1219,6 +1219,14 @@ mutation wrappers around the raw Fusion API:
 - `safe_set_inputs(tool_name, inputs, readback?)`
 - `safe_connect_tools(target_tool, input_name, source_tool, dry_run?)`
 - `fusion_boundary_report(include_io?)`
+- `add_fusion_mask(mask_type?, width?, height?, corner_radius?, center?|center_x?/center_y?,
+  angle?, soft_edge?, border_width?, invert?, inputs?, connect_to?, connect_input?, readback?)`
+  — one-call Rectangle/Ellipse mask (e.g. rounded corners): adds the mask tool, sets its
+  params (0..1), and optionally wires it into `connect_to`'s mask input (`EffectMask` default).
+- `set_text_plus(text, tool_name?, input_name?, readback?)` / `get_text_plus(tool_name?, input_name?)`
+  — read/write the text of a Fusion `Text+` tool or Fusion title template (e.g. a "Deep"
+  title). Auto-finds the `Text+` tool when `tool_name` is omitted; `input_name` defaults to
+  `StyledText`. For non-Fusion generator titles, use `timeline(action="set_title_text")` instead.
 
 ---
 

package/docs/install.md

@@ -59,6 +59,7 @@ The installer can automatically configure any of these clients:
 | Roo Code | VS Code global storage |
 | Zed | `~/.config/zed/settings.json` |
 | Continue | `~/.continue/config.json` |
+| OpenCode | `~/.config/opencode/opencode.json` (or project-root `opencode.json`) |
 | JetBrains IDEs | Manual (Settings > Tools > AI Assistant > MCP) |
 
 You can configure multiple clients at once, or use `--clients manual` to get copy-paste config snippets.

package/docs/process/release-process.md

@@ -86,6 +86,17 @@ env RESOLVE_SCRIPT_API="/Library/Application Support/Blackmagic Design/DaVinci R
   venv/bin/python tests/live_v233_validation.py
 ```
 
+For Fusion comp changes (masks, Text+/title text), run the issue #73 harness,
+which creates a disposable Fusion-title project, exercises `add_fusion_mask` and
+`set_text_plus` / `get_text_plus`, and deletes the project:
+
+```bash
+env RESOLVE_SCRIPT_API="/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting" \
+  RESOLVE_SCRIPT_LIB="/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so" \
+  PYTHONPATH="/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules" \
+  venv/bin/python tests/live_fusion_mask_title_validation.py
+```
+
 One-off live harnesses are acceptable during review, but reusable coverage
 should live under `tests/`. Do not commit generated media or disposable project
 artifacts.

package/docs/reference/api-coverage.md

@@ -44,6 +44,19 @@ maps `shot_descriptions[shot_index]` onto Media Pool shot markers, and triggers
 metadata writeback for that clip. Works with any MCP client whose chat model
 is vision-capable; no `sampling/createMessage` support required.
 
+Some Edit-page behavior is simply not reachable through public scripting. The
+**Source/Auto Track Selector** (the patch panel that chooses which video track a
+clip lands on) has no get/set in the API, and the `Insert*IntoTimeline` family
+(titles, generators, OFX, Fusion comps) takes no `trackIndex` — they always drop
+onto the selector's current target (V1 in practice). Locking lower tracks does
+not redirect the insert; it just makes the insert fail. Titles and generators
+can't be relocated afterward either, since they have no `MediaPoolItem` for
+`AppendToTimeline`/`MoveClips` to act on. For media-backed clips you *can* target
+a track via `MediaPool.AppendToTimeline`'s clipInfo `trackIndex` (exposed as
+`media_pool.append_to_timeline` with `clip_infos`). This limitation is recorded
+in the verified `api_truth` ledger (query `resolve_control api_truth "track"`);
+see issue #74.
+
 | Class | Methods | Tools | Description |
 |-------|---------|-------|-------------|
 | Resolve | 22 | 22 | App control, pages, layout presets, render/burn-in presets, keyframe mode |

package/install.py

@@ -4,7 +4,7 @@ DaVinci Resolve MCP Server — Universal Installer
 
 Supports: macOS, Windows, Linux
 Configures: Claude Desktop, Claude Code, Cursor, VS Code (Copilot),
-            Windsurf, Cline, Roo Code, Zed, Continue, and manual setup.
+            Windsurf, Cline, Roo Code, Zed, Continue, OpenCode, and manual setup.
 
 Usage:
     python install.py                  # Interactive mode
@@ -35,7 +35,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.56.1"
+VERSION = "2.57.1"
 # Only hard floor: mcp[cli] requires Python 3.10+. There is no upper bound —
 # Resolve's scripting bridge loads into newer interpreters on recent builds
 # (Python 3.14 verified against Resolve Studio 20.3.2). Older Resolve builds
@@ -392,6 +392,16 @@ MCP_CLIENTS = [
         "config_key": "mcpServers",
         "notes": "Open-source AI code assistant",
     },
+    {
+        "id": "opencode",
+        "name": "OpenCode",
+        # OpenCode uses ~/.config/opencode/opencode.json on every platform
+        # (it also reads a project-root opencode.json, but the global file is
+        # the safe default for an installer). See https://opencode.ai/docs/config/
+        "get_path": lambda: home() / ".config" / "opencode" / "opencode.json",
+        "config_key": "mcp",
+        "notes": "AI coding agent (uses its own type/enabled/command-array format)",
+    },
 ]
 
 CLIENT_IDS = [c["id"] for c in MCP_CLIENTS]
@@ -456,6 +466,33 @@ def build_zed_entry(python_path, server_path, api_path, lib_path, system=SYSTEM,
         "settings": {},
     }
 
+
+def build_opencode_entry(python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
+    """Build OpenCode-specific server entry (issue #72).
+
+    OpenCode's schema differs from the standard format in three ways: it wraps
+    the entry in a ``"mcp"`` key, the interpreter and script are a single
+    ``"command"`` array (no separate ``args``), and the environment block is
+    ``"environment"`` rather than ``"env"``. It also expects ``type``/``enabled``
+    discriminators. See https://opencode.ai/docs/mcp-servers/
+    """
+    return {
+        "type": "local",
+        "enabled": True,
+        "command": [str(python_path), str(server_path)],
+        "environment": build_server_env(python_path, api_path, lib_path, system=system, python_home=python_home),
+    }
+
+
+def build_entry_for_client(client, python_path, server_path, api_path, lib_path, system=SYSTEM, python_home=None):
+    """Return the server entry shaped for a specific client's config schema."""
+    builders = {
+        "zed": build_zed_entry,
+        "opencode": build_opencode_entry,
+    }
+    builder = builders.get(client["id"], build_server_entry)
+    return builder(python_path, server_path, api_path, lib_path, system=system, python_home=python_home)
+
 # ─── Config File Operations ──────────────────────────────────────────────────
 
 class ConfigParseError(Exception):
@@ -599,13 +636,9 @@ def write_client_config(client, python_path, server_path, api_path, lib_path, dr
         return False, f"{client['name']} is not available on {platform_name()}"
 
     config_key = client["config_key"]
-    is_zed = client["id"] == "zed"
 
-    # Build the server entry
-    if is_zed:
-        server_entry = build_zed_entry(python_path, server_path, api_path, lib_path)
-    else:
-        server_entry = build_server_entry(python_path, server_path, api_path, lib_path)
+    # Build the server entry (some clients use a non-standard schema)
+    server_entry = build_entry_for_client(client, python_path, server_path, api_path, lib_path)
 
     if dry_run:
         preview = {config_key: {"davinci-resolve": server_entry}}
@@ -637,12 +670,14 @@ def generate_manual_config(python_path, server_path, api_path, lib_path):
     """Generate config snippets for manual setup."""
     entry = build_server_entry(python_path, server_path, api_path, lib_path)
     zed_entry = build_zed_entry(python_path, server_path, api_path, lib_path)
+    opencode_entry = build_opencode_entry(python_path, server_path, api_path, lib_path)
 
     standard = json.dumps({"mcpServers": {"davinci-resolve": entry}}, indent=2)
     vscode_fmt = json.dumps({"servers": {"davinci-resolve": entry}}, indent=2)
     zed_fmt = json.dumps({"context_servers": {"davinci-resolve": zed_entry}}, indent=2)
+    opencode_fmt = json.dumps({"mcp": {"davinci-resolve": opencode_entry}}, indent=2)
 
-    return standard, vscode_fmt, zed_fmt
+    return standard, vscode_fmt, zed_fmt, opencode_fmt
 
 # ─── Virtual Environment ─────────────────────────────────────────────────────
 
@@ -1539,7 +1574,7 @@ def main():
 
     # Show manual config
     if show_manual:
-        standard, vscode_fmt, zed_fmt = generate_manual_config(
+        standard, vscode_fmt, zed_fmt, opencode_fmt = generate_manual_config(
             python_path, server_path, api_path, lib_path
         )
         env_preview = build_server_env(python_path, api_path, lib_path)
@@ -1557,6 +1592,10 @@ def main():
         print()
         for line in zed_fmt.split("\n"):
             print(f"    {line}")
+        print(f"\n  {cyan('OpenCode format')} (add to ~/.config/opencode/opencode.json or a project opencode.json):")
+        print()
+        for line in opencode_fmt.split("\n"):
+            print(f"    {line}")
         print(f"\n  {cyan('JetBrains IDEs')} (IntelliJ, WebStorm, PyCharm, etc.):")
         print(f"    Settings → Tools → AI Assistant → Model Context Protocol (MCP)")
         print(f"    Add server with command: {python_path} {server_path}")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "davinci-resolve-mcp",
-  "version": "2.56.1",
+  "version": "2.57.1",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/src/granular/common.py

@@ -80,7 +80,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.56.1"
+VERSION = "2.57.1"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.56.1"
+VERSION = "2.57.1"
 
 import base64
 import os
@@ -21543,6 +21543,234 @@ def _fusion_tool_names(comp):
     return [name for name, _ in _iter_fusion_tools(comp)]
 
 
+# Friendly mask aliases -> Fusion tool RegID, for add_fusion_mask (issue #73).
+_MASK_TOOL_ALIASES = {
+    "rectangle": "RectangleMask",
+    "rect": "RectangleMask",
+    "rectanglemask": "RectangleMask",
+    "ellipse": "EllipseMask",
+    "ellipsemask": "EllipseMask",
+    "circle": "EllipseMask",
+}
+
+# Friendly param name -> Fusion input id, for add_fusion_mask. Center is handled
+# separately because it is a Point input (see _fusion_set_point_input).
+_MASK_INPUT_ALIASES = {
+    "corner_radius": "CornerRadius",   # RectangleMask only
+    "width": "Width",
+    "height": "Height",
+    "angle": "Angle",
+    "soft_edge": "SoftEdge",
+    "border_width": "BorderWidth",
+    "invert": "Invert",
+}
+
+
+def _fusion_set_point_input(tool, input_id, value):
+    """Set a Fusion Point input (e.g. a mask Center).
+
+    Point inputs do not accept a plain scalar; the fusionscript bridge variously
+    accepts a 2-element list or a 1-indexed table depending on platform/version.
+    Try the known encodings and report which one took (or the last error).
+    """
+    if isinstance(value, dict):
+        candidates = [value]
+    else:
+        try:
+            x, y = value[0], value[1]
+        except (TypeError, KeyError, IndexError):
+            return False, f"{input_id} must be [x, y] or {{1:x, 2:y}} (got {value!r})", None
+        candidates = [[x, y], {1: x, 2: y}, {"1": x, "2": y}]
+    last_err = None
+    for cand in candidates:
+        try:
+            tool.SetInput(input_id, cand)
+            return True, None, cand
+        except Exception as exc:  # noqa: BLE401 - bridge raises bare exceptions
+            last_err = str(exc)
+    return False, last_err, None
+
+
+def _fusion_add_mask(comp, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Add and configure a Rectangle/Ellipse mask in one call (issue #73).
+
+    Equivalent to add_tool + a sequence of set_input calls, plus optional wiring
+    of the mask into a downstream tool's mask input. Each input is applied
+    independently so a single unsupported parameter does not abort the rest.
+    """
+    raw_type = str(p.get("mask_type", "Rectangle")).strip().lower()
+    tool_type = _MASK_TOOL_ALIASES.get(raw_type)
+    if not tool_type:
+        return _err(
+            "mask_type must be one of: Rectangle, Ellipse "
+            f"(got {p.get('mask_type')!r})"
+        )
+
+    x = p.get("x", -1)
+    y = p.get("y", -1)
+    readback = bool(p.get("readback", True))
+
+    comp.Lock()
+    try:
+        tool = comp.AddTool(tool_type, x, y)
+        if not tool:
+            return _err(
+                f"Failed to add {tool_type}. Verify the comp is editable "
+                "(switch to the Fusion page or target a clip with a Fusion comp)."
+            )
+        name = p.get("name")
+        if name:
+            tool.SetAttrs({"TOOLS_Name": str(name)})
+        attrs = tool.GetAttrs() or {}
+        tool_name = attrs.get("TOOLS_Name", "")
+
+        results: List[Dict[str, Any]] = []
+
+        # Center: accept center=[x,y]/{1:x,2:y}, or center_x / center_y.
+        center = p.get("center")
+        cx, cy = p.get("center_x"), p.get("center_y")
+        if center is None and (cx is not None or cy is not None):
+            center = [cx if cx is not None else 0.5, cy if cy is not None else 0.5]
+        if center is not None:
+            ok, err, applied = _fusion_set_point_input(tool, "Center", center)
+            rec = {"input": "Center", "value": center, "success": ok}
+            if not ok:
+                rec["error"] = err
+            elif readback:
+                try:
+                    rec["readback"] = _ser(tool.GetInput("Center"))
+                except Exception as exc:
+                    rec["readback_error"] = str(exc)
+            results.append(rec)
+
+        # Scalar inputs (friendly aliases) + any raw passthrough inputs.
+        to_set: List[tuple] = []
+        for friendly, fusion_id in _MASK_INPUT_ALIASES.items():
+            if friendly in p:
+                to_set.append((fusion_id, p[friendly]))
+        raw_inputs = p.get("inputs")
+        if isinstance(raw_inputs, dict):
+            for k, v in raw_inputs.items():
+                to_set.append((str(k), v))
+
+        for fusion_id, value in to_set:
+            rec = {"input": fusion_id, "value": value}
+            try:
+                tool.SetInput(fusion_id, value)
+                rec["success"] = True
+                if readback:
+                    try:
+                        rec["readback"] = _ser(tool.GetInput(fusion_id))
+                    except Exception as exc:
+                        rec["readback_error"] = str(exc)
+            except Exception as exc:
+                rec["success"] = False
+                rec["error"] = str(exc)
+            results.append(rec)
+
+        out: Dict[str, Any] = {
+            "success": True,
+            "tool_name": tool_name,
+            "tool_type": attrs.get("TOOLS_RegID", tool_type),
+            "inputs_set": results,
+        }
+
+        # Optional wiring: connect this mask into a tool's mask input.
+        connect_to = p.get("connect_to")
+        if connect_to:
+            input_name = p.get("connect_input", "EffectMask")
+            target = comp.FindTool(str(connect_to))
+            if not target:
+                out["connection"] = {
+                    "success": False,
+                    "error": f"connect_to tool '{connect_to}' not found",
+                }
+            else:
+                try:
+                    ok = bool(target.ConnectInput(input_name, tool))
+                    out["connection"] = {
+                        "success": ok,
+                        "target": str(connect_to),
+                        "input_name": input_name,
+                    }
+                except Exception as exc:
+                    out["connection"] = {"success": False, "error": str(exc)}
+        return out
+    finally:
+        comp.Unlock()
+
+
+def _fusion_find_text_tool(comp, p: Dict[str, Any]):
+    """Find a Text+ (TextPlus) tool in the comp, or the named tool. (issue #73)"""
+    name = p.get("tool_name")
+    if name:
+        tool = comp.FindTool(str(name))
+        if not tool:
+            return None, _err(f"Tool '{name}' not found")
+        return tool, None
+    # Auto-detect the first Text+ tool — this is what a Fusion title template
+    # (e.g. "Deep") exposes its editable copy through.
+    for name_, tool in _iter_fusion_tools(comp):
+        try:
+            reg = (tool.GetAttrs() or {}).get("TOOLS_RegID", "")
+        except Exception:
+            reg = ""
+        if reg in ("TextPlus", "Text+") or "Text" in reg:
+            return tool, None
+    return None, _err(
+        "No Text+ tool found in this comp. Pass tool_name explicitly, or call "
+        "get_tool_list to inspect the node graph."
+    )
+
+
+def _fusion_set_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Set the text of a Fusion Text+ tool / title template. (issue #73)"""
+    text = p.get("text")
+    if not isinstance(text, str):
+        return _err("set_text_plus requires params.text (string)")
+    tool, err = _fusion_find_text_tool(comp, p)
+    if err:
+        return err
+    input_id = p.get("input_name", "StyledText")
+    readback = bool(p.get("readback", True))
+    comp.Lock()
+    try:
+        try:
+            tool.SetInput(input_id, text)
+        except Exception as exc:
+            return _err(f"SetInput({input_id!r}) failed: {exc}")
+        out = {
+            "success": True,
+            "tool_name": (tool.GetAttrs() or {}).get("TOOLS_Name", ""),
+            "input_name": input_id,
+        }
+        if readback:
+            try:
+                out["readback"] = _ser(tool.GetInput(input_id))
+            except Exception as exc:
+                out["readback_error"] = str(exc)
+        return out
+    finally:
+        comp.Unlock()
+
+
+def _fusion_get_text_plus(comp, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Read the text of a Fusion Text+ tool / title template. (issue #73)"""
+    tool, err = _fusion_find_text_tool(comp, p)
+    if err:
+        return err
+    input_id = p.get("input_name", "StyledText")
+    try:
+        val = tool.GetInput(input_id)
+    except Exception as exc:
+        return _err(f"GetInput({input_id!r}) failed: {exc}")
+    return {
+        "tool_name": (tool.GetAttrs() or {}).get("TOOLS_Name", ""),
+        "input_name": input_id,
+        "text": _ser(val),
+    }
+
+
 @mcp.tool()
 def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
     """Fusion composition node graph operations.
@@ -21598,6 +21826,17 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
       safe_set_inputs(tool_name, inputs, readback?) -> {success, results}
       safe_connect_tools(target_tool, input_name, source_tool, dry_run?) -> {success}
       fusion_boundary_report(include_io?) -> {capabilities, composition}
+      add_fusion_mask(mask_type?, name?, center?|center_x?|center_y?, width?, height?,
+        corner_radius?, angle?, soft_edge?, border_width?, invert?, inputs?, x?, y?,
+        connect_to?, connect_input?, readback?) -> {success, tool_name, inputs_set, connection?}
+        mask_type: "Rectangle" (default) or "Ellipse". One call = add the mask tool,
+        set its params (corner_radius/width/height/center are 0..1), and optionally
+        wire it into connect_to's mask input (connect_input default "EffectMask").
+      set_text_plus(text, tool_name?, input_name?, readback?) -> {success, tool_name, readback?}
+        Set the text of a Fusion Text+ tool / title template (e.g. a "Deep" Fusion
+        title). Auto-finds the Text+ tool if tool_name is omitted; input_name
+        defaults to "StyledText".
+      get_text_plus(tool_name?, input_name?) -> {tool_name, input_name, text}
 
     Common tool_type values: Merge, Background, TextPlus, Transform, Blur,
       ColorCorrector, RectangleMask, EllipseMask, Tracker, MediaIn, MediaOut,
@@ -21637,6 +21876,12 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
         return _safe_connect_fusion_tools(comp, p)
     elif action == "fusion_boundary_report":
         return _fusion_boundary_report(comp, p)
+    elif action == "add_fusion_mask":
+        return _fusion_add_mask(comp, p)
+    elif action == "set_text_plus":
+        return _fusion_set_text_plus(comp, p)
+    elif action == "get_text_plus":
+        return _fusion_get_text_plus(comp, p)
 
     # --- Node Management ---
     if action == "add_tool":
@@ -22020,6 +22265,7 @@ def fusion_comp(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
         "get_position","set_position","copy_tool","auto_arrange",
         "bulk_set_inputs",
         "bulk_set_expressions",
+        "add_fusion_mask","set_text_plus","get_text_plus",
         *_FUSION_GROUP_KERNEL_ACTIONS,
         *_FUSION_KERNEL_ACTIONS,
     ])

package/src/utils/api_truth.py

@@ -158,6 +158,28 @@ API_TRUTH: List[Dict[str, Any]] = [
                        "need a comp to operate on.",
         "tags": ["fusion", "timeline"],
     },
+    {
+        "symbol": "Source Track Selector / destination track for Insert*IntoTimeline",
+        "object": "Timeline",
+        "reality": "There is no API to read or set the Source/Auto Track Selector "
+                   "(the Edit-page patch panel that picks the destination track). "
+                   "InsertTitleIntoTimeline, InsertFusionTitleIntoTimeline, "
+                   "InsertGeneratorIntoTimeline, InsertFusionGeneratorIntoTimeline, "
+                   "InsertOFXGeneratorIntoTimeline and "
+                   "InsertFusionCompositionIntoTimeline take no trackIndex and "
+                   "always drop the clip on the selector's current target (V1 in "
+                   "practice). Locking lower video tracks does NOT redirect the "
+                   "insert — verified live on 21.0.0: locking V1 makes the insert "
+                   "FAIL rather than land on V2. Titles/generators also can't be "
+                   "moved afterward (no MediaPoolItem, so AppendToTimeline clipInfo "
+                   "and MoveClips don't apply).",
+        "recommended": "Accept the limitation for titles/generators (insert lands "
+                       "on V1). For clips that DO have a MediaPoolItem, target a "
+                       "track with MediaPool.AppendToTimeline's clipInfo 'trackIndex' "
+                       "instead (exposed as media_pool append_to_timeline clip_infos). "
+                       "See issue #74.",
+        "tags": ["missing-method", "timeline", "title", "generator", "track"],
+    },
     {
         "symbol": "subprocess inheriting stdin under the MCP stdio server",
         "object": "(server runtime)",