davinci-resolve-mcp 2.80.2 → 2.81.0

package/CHANGELOG.md

@@ -2,6 +2,73 @@
 
 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.81.0
+
+One render bug where every readback agreed and the file disagreed, plus the two
+community skill contributions that were open against it.
+
+### Fixed
+
+- **`prepare_render_job` inherited the Deliver page's loaded preset, and could
+  queue an mp4 that rendered with no video stream** (issue #123, reported with
+  a full measurement by @chenyuxiaojin). `SetRenderSettings` applies the keys a
+  caller passes *on top of* whatever render state the Deliver page is holding
+  rather than replacing it, and a loaded preset carries more state than those
+  keys. Measured 2026-07-08: after an MP3 render through the stock **Audio
+  Only** preset, a job queued with an explicit `ExportVideo: true` and an `.mp4`
+  target returned `settings_success: true` and a real `job_id`, `list_jobs`
+  reported `IsExportVideo: true`, and the rendered file held only an AAC stream.
+  The single visible tell was 18 minutes of material "rendering" in ~10 seconds.
+
+  No caller-side check could have caught it, and the reason is worse than the
+  bug itself: the scripting API documents neither `GetRenderSettings` nor
+  `GetCurrentRenderPresetName`, so the inherited state cannot be read at all.
+  Detection is unreachable; only pinning is.
+
+### Added
+
+- **`from_preset` on `prepare_render_job`** (and through
+  `prepare_delivery_job`) runs `LoadRenderPreset` before the explicit settings
+  go on top, so a caller pins the base state instead of inheriting one.
+  `PresetName` flipping to `Custom` once the explicit settings land is expected.
+  The name is validated against `GetRenderPresetList` first, because
+  `LoadRenderPreset` refuses an unknown name with a bare `False` that is
+  indistinguishable from any other refusal — and a `False` of either kind now
+  refuses to queue rather than falling through to an inheriting render.
+- **An inherited-state warning** when a job asks for `ExportVideo: true` without
+  a pin, naming the risk and saying plainly that the job readback is not a
+  witness for the rendered file — verify a `codec_type=video` stream before
+  reporting a deliverable. The `before` snapshot now also reports
+  `settings_readable: false` and what is unreadable, instead of leaving the gap
+  unnamed.
+- **`resolve-tighten-recording` skill** (PR #126, @chenyuxiaojin) — the
+  subtractive counterpart to `resolve-rough-cut`: one long single-take recording
+  in, a tightened variant timeline out, original untouched. Measured live
+  against Studio 21.0.1.11 on a real 28.5-minute recording. Its centerpiece is
+  the coordinate-system trap between plan `keep_ranges` (source frames,
+  exclusive end) and `structural_diff.added` (record frames) — feed one where
+  the other is expected and every clip lands at the wrong moment of the right
+  file, with correct cut lengths and no error. Also documents the three classes
+  of content silence-driven tightening cannot hear, including the whisper
+  swallowed-retake blind spot (issue #125).
+
+### Changed
+
+- **`resolve-rough-cut` reconciled with the `api_truth` ledger** (PR #115,
+  @bolnet). Two rows contradicted the ledger the skill itself points at. Import
+  order was backwards — `ImportMedia` has no destination parameter and always
+  lands in the *current* folder, so the bin must be created and made current
+  *before* importing. And the traps table still asserted that a comp attached to
+  a media clip "never renders", a blanket claim the ledger retracted on
+  2026-08-02: a comp wired `MediaIn → Blur → MediaOut` does render, and an
+  unrooted `MediaOut` fails the render job outright rather than being silently
+  bypassed. Every row now names the build it was confirmed on, and a note
+  records that a **running** MCP keeps executing the version it started with, so
+  `git pull` does not refresh the ledger until restart.
+- The skill index in `docs/README.md` now lists the two end-to-end assembly
+  recipes (`resolve-rough-cut`, `resolve-tighten-recording`), neither of which
+  had ever appeared there, and `resolve-edit` points at the tighten skill.
+
 ## What's New in v2.80.2
 
 Agent tooling only. Ten Claude Code skills that this repository has shipped and

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.80.2-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.81.0-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)

package/docs/README.md

@@ -61,7 +61,15 @@ Each skill is a directory containing `SKILL.md`. Claude Code does not discover
 loose `.md` files in `.claude/skills/`; a skill placed at the top level of that
 directory silently never loads.
 
-Two skills sit outside the domain routing:
+Two end-to-end assembly recipes sit alongside the domain skills. Where a domain
+skill routes, these two walk a whole job:
+
+- `resolve-rough-cut` (`.claude/skills/resolve-rough-cut/SKILL.md`) — **additive**:
+  select shots from a folder of many clips into an assembled timeline.
+- `resolve-tighten-recording` (`.claude/skills/resolve-tighten-recording/SKILL.md`)
+  — **subtractive**: remove dead air from one long single-take recording.
+
+Two more sit outside the domain routing:
 
 - `house-style` (`.claude/skills/house-style/SKILL.md`) — accumulated editorial
   corrections, so the same note is not given twice. Claude-only; append to it

package/docs/reference/api-limitations.md

@@ -12,7 +12,7 @@ that none exists).
 
 **Verified on:** DaVinci Resolve Studio 21.0.2
 
-**Totals:** 25 missing capabilities, 28 bugs / unreliable behaviors.
+**Totals:** 25 missing capabilities, 29 bugs / unreliable behaviors.
 
 The authoritative source is the runtime-queryable `api_truth` ledger
 (`resolve_control api_truth "<query>"`); this document is generated from
@@ -436,6 +436,15 @@ values, or automation-hostile modal prompts.
 - **Reference:** [issue #59](https://github.com/samuelgursky/davinci-resolve-mcp/issues/59)
 - **Tags:** render, deliver, silent-failure, id-vs-label
 
+### Project.SetRenderSettings (inherits the loaded preset)
+
+- **Object:** `Project`
+- **Signature:** `({settings}) -> bool`
+- **Behavior:** SetRenderSettings applies the passed keys ON TOP of whatever render state the Deliver page is holding; it does not replace it. A loaded preset carries more state than the keys a caller passes, and that state survives. Measured 2026-07-08: after a render through the stock 'Audio Only' preset, a job queued with an explicit ExportVideo=True and an .mp4 target returned settings_success=True and a real job id, GetRenderJobList reported IsExportVideo=True, and the rendered .mp4 contained only an AAC stream with NO video stream (ffprobe) — 18 minutes of material 'rendered' in ~10 seconds. The job readback is therefore NOT a witness for the rendered file. There is also no way to detect the inherited state: the scripting API documents no GetRenderSettings and no GetCurrentRenderPresetName, so the base state can be pinned but never read.
+- **Workaround / current handling:** Pin the base state instead of inheriting one — prepare_render_job(from_preset='<a video preset>') runs LoadRenderPreset before the explicit settings go on top (PresetName flips to 'Custom' once they do, which is expected). Then verify the OUTPUT, not the job: ffprobe for a codec_type=video stream. A long timeline that completes in seconds is the tell.
+- **Reference:** [issue #123](https://github.com/samuelgursky/davinci-resolve-mcp/issues/123)
+- **Tags:** render, deliver, silent-failure, preset, readback-lies
+
 ### ProjectManager.SaveProject
 
 - **Object:** `ProjectManager`

package/install.py

@@ -36,7 +36,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.80.2"
+VERSION = "2.81.0"
 # 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

package/package.json

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

package/src/granular/common.py

@@ -85,7 +85,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.80.2"
+VERSION = "2.81.0"
 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.80.2"
+VERSION = "2.81.0"
 
 import base64
 import os
@@ -16124,13 +16124,66 @@ def _render_settings_snapshot(proj):
         settings = _ser(proj.GetRenderSettings())
     else:
         settings = {"error": "GetRenderSettings unavailable"}
-    return {
+    snapshot = {
         "format_and_codec": _ser(proj.GetCurrentRenderFormatAndCodec()),
         "mode": _ser(proj.GetCurrentRenderMode()),
         "settings": settings,
         "jobs": _ser(proj.GetRenderJobList() or []),
         "is_rendering": bool(proj.IsRenderingInProgress()),
     }
+    # The Deliver page's loaded preset carries render state beyond the keys a
+    # caller passes, and SetRenderSettings applies on TOP of it rather than
+    # replacing it. The scripting API exposes no reader for either half — there
+    # is no GetCurrentRenderPresetName, and GetRenderSettings is not in the
+    # documented surface — so this snapshot cannot report what is being
+    # inherited. Say that in the payload instead of leaving the gap unnamed.
+    if not isinstance(settings, dict) or "error" in settings:
+        snapshot["settings_readable"] = False
+        snapshot["inherited_state"] = (
+            "unreadable: no GetRenderSettings / GetCurrentRenderPresetName in the "
+            "scripting API. Whatever preset the Deliver page holds survives into "
+            "this job for every key not explicitly passed. Pass from_preset to pin "
+            "the base state."
+        )
+    else:
+        snapshot["settings_readable"] = True
+    return snapshot
+
+
+def _render_preset_pin(proj, preset_name: str):
+    """LoadRenderPreset with the name validated against the live preset list.
+
+    Returns (result_dict, err). LoadRenderPreset returns a bare False for a name
+    that does not exist, which is indistinguishable from any other refusal, so
+    the name is checked first and a miss names the available presets.
+    """
+    try:
+        available = [str(x) for x in (proj.GetRenderPresetList() or [])]
+    except Exception:
+        available = []
+    if available and preset_name not in available:
+        return None, _err(
+            f"Render preset not found: {preset_name}",
+            code="RENDER_PRESET_NOT_FOUND",
+            category="invalid_input",
+            reason="LoadRenderPreset refuses an unknown name with a bare False; no job was queued.",
+            remediation="Use render(action='list_presets') for the names this project carries.",
+            state={"requested_preset": preset_name, "available_presets": available},
+        )
+    loaded = bool(proj.LoadRenderPreset(preset_name))
+    if not loaded:
+        return None, _err(
+            f"Could not load render preset: {preset_name}",
+            code="RENDER_PRESET_LOAD_FAILED",
+            category="engine_refused",
+            reason=(
+                "LoadRenderPreset returned False. Refusing to queue: the job would "
+                "otherwise inherit whatever unrelated state the Deliver page holds."
+            ),
+            remediation="Check render(action='list_presets'), then retry.",
+            state={"requested_preset": preset_name, "available_presets": available},
+        )
+    return {"preset": preset_name, "loaded": True}, None
 
 
 def _validate_render_settings_payload(settings: Dict[str, Any], *, require_temp_target: bool = False):
@@ -16230,6 +16283,16 @@ def _prepare_render_job(proj, p: Dict[str, Any]):
     if p.get("dry_run"):
         return _ok(validation=validation, format=p.get("format"), codec=p.get("codec"))
     before = _render_settings_snapshot(proj)
+    # Pin the base render state before layering explicit settings on top. Without
+    # this the job inherits the Deliver page's loaded preset for every key the
+    # caller does not pass — an Audio Only preset plus ExportVideo:True has been
+    # measured to queue a job that reads back IsExportVideo:True and renders an
+    # mp4 with no video stream (issue #123).
+    preset_pin = None
+    if p.get("from_preset"):
+        preset_pin, err = _render_preset_pin(proj, str(p["from_preset"]))
+        if err:
+            return err
     format_success = None
     if p.get("format") and p.get("codec"):
         formats = _render_formats(proj)
@@ -16261,7 +16324,7 @@ def _prepare_render_job(proj, p: Dict[str, Any]):
             )
     settings_success = bool(proj.SetRenderSettings(settings))
     job_id = proj.AddRenderJob() if settings_success else None
-    return {
+    result = {
         "success": bool(job_id),
         "job_id": job_id,
         "format_success": format_success,
@@ -16269,6 +16332,30 @@ def _prepare_render_job(proj, p: Dict[str, Any]):
         "before": before,
         "settings": settings,
     }
+    if preset_pin:
+        result["preset_pinned"] = preset_pin
+    elif settings.get("ExportVideo") is True:
+        # No pin, and the caller is asking for video. This is the exact shape
+        # that produced a video-less mp4 in issue #123: the queued job's
+        # IsExportVideo readback agreed with the request and the file did not.
+        # The job readback is not a witness for the rendered file, so say so
+        # here rather than let success=True imply a verified deliverable.
+        result["warnings"] = result.get("warnings", []) + [{
+            "code": "RENDER_PRESET_STATE_INHERITED",
+            "message": (
+                "This job inherits the Deliver page's current render state for every "
+                "key not passed in settings, and that state is not readable from the "
+                "scripting API. A previously loaded audio-only preset has been measured "
+                "to survive an explicit ExportVideo:true and render an mp4 with no video "
+                "stream, while the job readback reported IsExportVideo:true."
+            ),
+            "remediation": (
+                "Pass from_preset='<a video preset>' to pin the base state, and verify "
+                "the rendered file has a codec_type=video stream before reporting it "
+                "delivered — a long timeline that 'renders' in seconds is the tell."
+            ),
+        }]
+    return result
 
 
 # ── Delivery targets ────────────────────────────────────────────────────────
@@ -16585,7 +16672,11 @@ def render(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
       probe_render_settings() -> {format_and_codec, mode, settings, jobs, is_rendering}
       validate_render_settings(settings, require_temp_target?) -> {valid, errors, unknown_keys}
       safe_set_render_settings(settings, dry_run?, restore?, require_temp_target?) -> {success, diff}
-      prepare_render_job(target_dir, settings?, format?, codec?, custom_name?, dry_run?) -> {success, job_id}
+      prepare_render_job(target_dir, settings?, format?, codec?, custom_name?, from_preset?, dry_run?) -> {success, job_id}
+        from_preset pins the base render state (LoadRenderPreset) before the
+        explicit settings go on top. Without it the job inherits the Deliver
+        page's loaded preset for every key not passed, which the API gives no
+        way to read back — see the SetRenderSettings api_truth entry.
       render_job_lifecycle_probe(target_dir, settings?, format?, codec?, custom_name?) -> {success, job_id, status_before_delete}
       quick_export_capabilities() -> {presets, safe_params, guards}
       safe_quick_export(preset, target_dir?|params?, custom_name?, dry_run?, allow_render?) -> {success, status}

package/src/utils/api_truth.py

@@ -1373,6 +1373,36 @@ API_TRUTH: List[Dict[str, Any]] = [
         "issue": 59,
         "mitigation": ["_render_format_id", "_render_codec_id"],
     },
+    {
+        "symbol": "Project.SetRenderSettings (inherits the loaded preset)",
+        "object": "Project",
+        "signature": "({settings}) -> bool",
+        "reality": "SetRenderSettings applies the passed keys ON TOP of whatever "
+                   "render state the Deliver page is holding; it does not replace "
+                   "it. A loaded preset carries more state than the keys a caller "
+                   "passes, and that state survives. Measured 2026-07-08: after a "
+                   "render through the stock 'Audio Only' preset, a job queued with "
+                   "an explicit ExportVideo=True and an .mp4 target returned "
+                   "settings_success=True and a real job id, GetRenderJobList "
+                   "reported IsExportVideo=True, and the rendered .mp4 contained "
+                   "only an AAC stream with NO video stream (ffprobe) — 18 minutes "
+                   "of material 'rendered' in ~10 seconds. The job readback is "
+                   "therefore NOT a witness for the rendered file. There is also no "
+                   "way to detect the inherited state: the scripting API documents "
+                   "no GetRenderSettings and no GetCurrentRenderPresetName, so the "
+                   "base state can be pinned but never read.",
+        "recommended": "Pin the base state instead of inheriting one — "
+                       "prepare_render_job(from_preset='<a video preset>') runs "
+                       "LoadRenderPreset before the explicit settings go on top "
+                       "(PresetName flips to 'Custom' once they do, which is "
+                       "expected). Then verify the OUTPUT, not the job: ffprobe for "
+                       "a codec_type=video stream. A long timeline that completes "
+                       "in seconds is the tell.",
+        "tags": ["render", "deliver", "silent-failure", "preset", "readback-lies"],
+        "submit": "bug",
+        "issue": 123,
+        "mitigation": ["_render_preset_pin", "_prepare_render_job"],
+    },
     {
         "symbol": "Project.SetCurrentRenderFormatAndCodec",
         "object": "Project",