davinci-resolve-mcp 2.104.0 → 2.104.2

package/src/utils/api_truth.py

@@ -1875,10 +1875,20 @@ API_TRUTH: List[Dict[str, Any]] = [
                    "(frame 0 == first frame), while recordFrame and "
                    "TimelineItem.GetStart/GetEnd are absolute. Distinct from "
                    "the null-id entry below, which is a recordFrame landing in "
-                   "an OCCUPIED span rather than before the start. Verified on "
+                   "an OCCUPIED span rather than before the start. Worse, the "
+                   "render JOB's own metadata lies too: Resolve rewrites the "
+                   "job's MarkIn/MarkOut down to the collapsed extent (measured "
+                   "live on 19.1.3.7: 96 frames of content before start -> an "
+                   "explicit 96-frame mark range became a 1-frame job, Complete "
+                   "at 100%, a 1-frame black stub), so output-duration vs "
+                   "job-mark-range checks read clean. The only truthful "
+                   "readback is the timeline items themselves, which report "
+                   "their real GetStart/GetEnd — before the start frame. "
+                   "Verified on "
                    "Studio 20.3.2.9 (v2.17.1 probe: relative record_frame 12 "
-                   "landed at 86400 + 12 = 86412, absolute preserved 86484) and "
-                   "independently on Studio 21.0.4.5 (issue #164).",
+                   "landed at 86400 + 12 = 86412, absolute preserved 86484), "
+                   "independently on Studio 21.0.4.5 (issue #164), and the "
+                   "mark-range rewrite on Studio 19.1.3.7 (2026-08-29).",
         "recommended": "Offset every recordFrame by timeline.GetStartFrame(). "
                        "This server already does it: "
                        "media_pool.append_to_timeline defaults to "
@@ -1888,8 +1898,10 @@ API_TRUTH: List[Dict[str, Any]] = [
                        "value below the timeline start is refused outright. "
                        "When driving the API directly, "
                        "never treat JobStatus Complete as proof a render "
-                       "worked — check the output file's duration, not just "
-                       "that the job finished.",
+                       "worked — and do not trust the job's MarkIn/MarkOut as "
+                       "the expected duration either. render.verify_output "
+                       "(v2.104.1) cross-checks the job against its timeline's "
+                       "item extents and flags items before the start frame.",
         "tags": ["timeline", "edit", "render", "silent-failure", "media-pool"],
         "issue": 164,
     },

package/src/utils/app_control.py

@@ -78,13 +78,23 @@ def quit_resolve_app(resolve_obj, force: bool = False, save_project: bool = True
             if project and save_project:
                 logger.info("Saving project before quitting")
                 # Try to save the project
+                # Only the exception was handled. SaveProject also reports a
+                # refusal with a bare False -- which is what a project attached
+                # to no database returns -- and quitting on that throws the
+                # session away silently.
                 try:
-                    project.SaveProject()
+                    saved = project.SaveProject()
                 except Exception as e:
                     logger.error(f"Failed to save project: {str(e)}")
                     if not force:
                         logger.error("Aborting quit due to save failure")
                         return False
+                else:
+                    if saved is False:
+                        logger.error("SaveProject returned False; the project was NOT saved")
+                        if not force:
+                            logger.error("Aborting quit due to save failure")
+                            return False
         
         # Attempt to quit using the API
         if hasattr(resolve_obj, 'Quit') and callable(getattr(resolve_obj, 'Quit')):

package/src/utils/audio_fairlight_live_probe.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 
 def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
@@ -146,7 +147,13 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         timeline = media_pool.CreateTimelineFromClips(timeline_name, [video_clip])
         if not timeline:
             raise AssertionError("Failed to create audio timeline")
-        project.SetCurrentTimeline(timeline)
+        # A discarded False here would run the whole probe against whatever
+        # timeline was already current, and every measurement below would be a
+        # reading of the wrong thing reported as a reading of this one.
+        switched, switch_detail = set_current_timeline(project, timeline)
+        if not switched:
+            raise AssertionError(
+                describe_switch_failure(switch_detail, "probing the audio timeline"))
         print(f"Created timeline: {timeline_name}")
 
         video_clip_id = _clip_id(video_clip)

package/src/utils/color_grade_live_probe.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 
 def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
@@ -188,7 +189,13 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         timeline = media_pool.CreateTimelineFromClips(timeline_name, [clip])
         if not timeline:
             raise AssertionError("Failed to create color grade timeline")
-        project.SetCurrentTimeline(timeline)
+        # A discarded False here would run the whole probe against whatever
+        # timeline was already current, and every measurement below would be a
+        # reading of the wrong thing reported as a reading of this one.
+        switched, switch_detail = set_current_timeline(project, timeline)
+        if not switched:
+            raise AssertionError(
+                describe_switch_failure(switch_detail, "probing the color grade timeline"))
         media_pool.AppendToTimeline([clip])
         timeline.SetCurrentTimecode("01:00:00:01")
         server.resolve_control("open_page", {"page": "color"})

package/src/utils/fusion_composition_live_probe.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 
 def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
@@ -139,7 +140,13 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         timeline = media_pool.CreateTimelineFromClips(timeline_name, [clip])
         if not timeline:
             raise AssertionError("Failed to create Fusion timeline")
-        project.SetCurrentTimeline(timeline)
+        # A discarded False here would run the whole probe against whatever
+        # timeline was already current, and every measurement below would be a
+        # reading of the wrong thing reported as a reading of this one.
+        switched, switch_detail = set_current_timeline(project, timeline)
+        if not switched:
+            raise AssertionError(
+                describe_switch_failure(switch_detail, "probing the Fusion timeline"))
         timeline.SetCurrentTimecode("01:00:00:01")
         print(f"Created timeline: {timeline_name}")
 

package/src/utils/probe_catalogue.py

@@ -25,6 +25,7 @@ from __future__ import annotations
 from typing import Any, List
 
 from src.utils.mode_matrix import Probe
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 CATALOGUE: List[Probe] = []
 
@@ -731,11 +732,22 @@ def _probe_editorial_nested(ctx):
               if (c.GetClipProperty("Type") or "") == "Timeline"]
     if not nested:
         return None
-    ctx.project.SetCurrentTimeline(outer)
+    # AppendToTimeline writes to the CURRENT timeline, so a discarded False
+    # here would nest the clip into ctx.timeline and then count PROBE_OUTER's
+    # empty track -- a measurement of the wrong timeline, reported as this one's.
+    switched, detail = set_current_timeline(ctx.project, outer)
+    if not switched:
+        return describe_switch_failure(detail, "nesting the probe timeline")
     appended = pool.AppendToTimeline([{"mediaPoolItem": nested[0]}])
     count = len(outer.GetItemListInTrack("video", 1) or [])
-    ctx.project.SetCurrentTimeline(ctx.timeline)
-    return f"{bool(appended)}/{count}"
+    restored, restore_detail = set_current_timeline(ctx.project, ctx.timeline)
+    result = f"{bool(appended)}/{count}"
+    if not restored:
+        # The measurement stands; the teardown did not. Say so in the result
+        # rather than leaving the next probe on PROBE_OUTER without warning.
+        result += " (probe timeline left current: " + \
+            describe_switch_failure(restore_detail, "restoring the probe timeline") + ")"
+    return result
 
 
 @probe("editorial.set_clips_linked", "editorial", timeout=90, needs=("timeline",),

package/src/utils/project_cleanup.py

@@ -13,9 +13,12 @@ disposable-project flow gets it for free:
    instead of silently leaking.
 """
 
+import logging
 import time
 from typing import Any, Dict, Optional
 
+logger = logging.getLogger("davinci-resolve-mcp.project_cleanup")
+
 
 #: The name Resolve gives the project it opens when it has nothing else to open.
 #: It has never been saved and has no location, so it cannot be saved.
@@ -103,10 +106,21 @@ def delete_project_safely(
             # cannot be saved, so the next close or switch raises a modal no
             # script can dismiss. That is a wedged application, not a tidy-up.
             if switch_to and switch_to != name:
+                # A discarded False leaves the session on the unsaveable
+                # "Untitled Project" this comment exists to avoid, and the next
+                # close or switch raises a modal no script can dismiss. Logged
+                # loudly: the caller is mid-delete and cannot be aborted here,
+                # but a silent wedge is what made this hard to diagnose.
                 try:
-                    pm.LoadProject(switch_to)
-                except Exception:
-                    pass
+                    if not pm.LoadProject(switch_to):
+                        logger.error(
+                            "LoadProject(%r) returned False after closing %r; the "
+                            "session is left on an unsaveable Untitled Project and "
+                            "the next close will raise a modal", switch_to, name,
+                        )
+                except Exception as exc:
+                    logger.error("LoadProject(%r) raised after closing %r: %s",
+                                 switch_to, name, exc)
 
         last_error = None
         for attempt in range(1 + max(0, int(retries))):

package/src/utils/render_deliver_live_probe.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 
 def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
@@ -183,7 +184,13 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         timeline = media_pool.CreateTimelineFromClips(timeline_name, [clip])
         if not timeline:
             raise AssertionError("Failed to create synthetic render timeline")
-        project.SetCurrentTimeline(timeline)
+        # A discarded False here would run the whole probe against whatever
+        # timeline was already current, and every measurement below would be a
+        # reading of the wrong thing reported as a reading of this one.
+        switched, switch_detail = set_current_timeline(project, timeline)
+        if not switched:
+            raise AssertionError(
+                describe_switch_failure(switch_detail, "probing the synthetic render timeline"))
         print(f"Created timeline: {timeline_name}")
 
         chosen = _choose_render_format_codec(server)

package/src/utils/resolve_bridge_client.py

@@ -236,7 +236,16 @@ class _BoundMethod:
         self._handle = handle
         self._name = name
 
-    def __call__(self, *args: Any) -> Any:
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        if kwargs:
+            raise TypeError(
+                f"{self._name}() was called with keyword argument(s) "
+                f"{sorted(kwargs)} through the in-app bridge, which proxies "
+                "Resolve calls positionally. Pass every argument positionally "
+                "(Resolve's own signatures accept it) — e.g. "
+                "StartRendering([job_ids], False) instead of "
+                "StartRendering([job_ids], isInteractiveMode=False)."
+            )
         result = self._transport.request(
             "call",
             {"target": self._handle, "method": self._name,

package/src/utils/resolve_writes.py

@@ -0,0 +1,79 @@
+"""Resolve mutators whose return value must not be discarded.
+
+Every write in the DaVinci Resolve scripting API reports itself with a bare
+boolean and nothing else. Dropping that boolean turns a failed write into a
+successful-looking no-op, which is the only failure shape worse than a crash:
+the tool reports what it meant to do, and the project does not have it.
+
+`SetCurrentTimeline` is the sharpest case in this repo, which is why it lives
+here. `AppendToTimeline`, `GetCurrentTimeline` and every other "current
+timeline" call writes to whatever the PROJECT believes is current, never to the
+handle in scope, so a discarded `False` sends an assembly to the timeline the
+editor was looking at while the caller reports the new timeline's name and id.
+"""
+
+from typing import Any, Dict, Optional, Tuple
+
+
+def unique_id(obj: Any) -> Optional[str]:
+    """`obj.GetUniqueId()`, or None. Never raises."""
+    if obj is None:
+        return None
+    try:
+        return obj.GetUniqueId()
+    except Exception:
+        return None
+
+
+def set_current_timeline(project: Any, timeline: Any) -> Tuple[bool, Dict[str, Any]]:
+    """Switch the project's current timeline. Returns (ok, detail).
+
+    The bare bool is not trusted on its own. A Resolve attached to no database
+    answers version queries normally while every project mutation returns False
+    or None, and a `True` that did not take has been observed there, so the
+    switch is confirmed by reading the current timeline back.
+
+    When the readback is unavailable (a build or transport that does not answer
+    `GetCurrentTimeline`) the bool is the only evidence there is, and it is
+    used. That is a weaker check, not a reason to refuse the work.
+
+    `detail` always carries `returned`, `wanted_timeline_id`,
+    `current_timeline_id` and, on an exception, `exception`.
+    """
+    detail: Dict[str, Any] = {
+        "returned": None,
+        "wanted_timeline_id": unique_id(timeline),
+        "current_timeline_id": None,
+    }
+    try:
+        detail["returned"] = project.SetCurrentTimeline(timeline)
+    except Exception as exc:
+        detail["exception"] = str(exc)
+        return False, detail
+
+    try:
+        detail["current_timeline_id"] = unique_id(project.GetCurrentTimeline())
+    except Exception:
+        detail["current_timeline_id"] = None
+
+    wanted = detail["wanted_timeline_id"]
+    current = detail["current_timeline_id"]
+    if wanted is not None and current is not None:
+        return wanted == current, detail
+    return bool(detail["returned"]), detail
+
+
+def describe_switch_failure(detail: Dict[str, Any], what: str) -> str:
+    """One line naming what did not happen, for a log or an error envelope."""
+    if "exception" in detail:
+        return (
+            f"Could not switch the current timeline before {what}: "
+            f"{detail['exception']}. Nothing was written."
+        )
+    return (
+        f"Could not switch the current timeline before {what}. "
+        f"SetCurrentTimeline returned {detail.get('returned')!r} and the current "
+        f"timeline is still {detail.get('current_timeline_id')!r}, not "
+        f"{detail.get('wanted_timeline_id')!r}. Continuing would write to the "
+        "wrong timeline while reporting success."
+    )

package/src/utils/review_annotation_live_probe.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 
 def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
@@ -148,7 +149,13 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         timeline = media_pool.CreateTimelineFromClips(timeline_name, [clip])
         if not timeline:
             raise AssertionError("Failed to create review annotation timeline")
-        project.SetCurrentTimeline(timeline)
+        # A discarded False here would run the whole probe against whatever
+        # timeline was already current, and every measurement below would be a
+        # reading of the wrong thing reported as a reading of this one.
+        switched, switch_detail = set_current_timeline(project, timeline)
+        if not switched:
+            raise AssertionError(
+                describe_switch_failure(switch_detail, "probing the review annotation timeline"))
         timeline.SetCurrentTimecode("01:00:00:01")
         print(f"Created timeline: {timeline_name}")
 

package/src/utils/timeline_conform_live_probe.py

@@ -14,6 +14,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from src.utils.timeline_kernel_probe import ProbeRecorder, render_markdown_report, utc_timestamp
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 
 def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]:
@@ -157,7 +158,13 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         )
         if not timeline:
             raise AssertionError("Failed to create conform timeline")
-        project.SetCurrentTimeline(timeline)
+        # A discarded False here would run the whole probe against whatever
+        # timeline was already current, and every measurement below would be a
+        # reading of the wrong thing reported as a reading of this one.
+        switched, switch_detail = set_current_timeline(project, timeline)
+        if not switched:
+            raise AssertionError(
+                describe_switch_failure(switch_detail, "probing the conform timeline"))
         media_pool.AppendToTimeline(
             [
                 {"mediaPoolItem": clip_b, "startFrame": 0, "endFrame": 48, "recordFrame": 86472, "trackIndex": 1, "mediaType": 1},

package/src/utils/timeline_kernel_live_probe.py

@@ -947,7 +947,13 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         audio_item = server._find_timeline_item_by_id(timeline, audio_id)
         if not audio_item:
             raise AssertionError(f"Could not recover audio item: {audio_id}")
-        timeline.SetClipsLinked([source_item, audio_item], True)
+        # Everything the probe measures below assumes the pair is linked. A
+        # discarded False would measure UNLINKED behaviour and record it as
+        # linked behaviour.
+        if not timeline.SetClipsLinked([source_item, audio_item], True):
+            raise AssertionError(
+                "SetClipsLinked refused the source/audio pair; every linked-item "
+                "measurement below would be a reading of unlinked items")
 
         source_duration = _frame_int(source_item.GetDuration())
         metadata["source"] = {

package/src/utils/timeline_versioning.py

@@ -35,6 +35,7 @@ from src.utils.resolve_probe import has_method
 from typing import Any, Dict, List, Optional, Tuple
 
 from src.utils import actor_identity, timeline_brain_db
+from .resolve_writes import set_current_timeline, describe_switch_failure
 
 logger = logging.getLogger("resolve-mcp.timeline-versioning")
 
@@ -166,7 +167,16 @@ def archive_current_timeline(
     # DuplicateTimeline drops the duplicate in the *current* folder (Archive),
     # but it also switches Resolve's current timeline to the duplicate. Restore
     # the working timeline as the active one so downstream mutation hits it.
-    project.SetCurrentTimeline(tl)
+    # A discarded False here sends every subsequent mutation into the ARCHIVE
+    # copy while the caller believes it is editing the working timeline, so the
+    # archive fails loudly instead.
+    switched, switch_detail = set_current_timeline(project, tl)
+    if not switched:
+        return {"success": False,
+                "error": describe_switch_failure(
+                    switch_detail, "returning to the working timeline after archiving"),
+                "archived_timeline_name": archived_name,
+                "switch": switch_detail}
 
     # Timebase snapshot — timeline_clip_usage stores ABSOLUTE record frames
     # (GetStart() includes the start-timecode offset), so readers need the
@@ -612,10 +622,13 @@ def rollback_to_version(
     if restored is None:
         return {"success": False, "error": f"DuplicateTimeline('{restored_name}') failed"}
 
-    project.SetCurrentTimeline(restored)
+    switched, switch_detail = set_current_timeline(project, restored)
 
     return {
         "success": True,
+        "current_timeline_switched": switched,
+        "switch_error": (None if switched else describe_switch_failure(
+            switch_detail, "opening the restored timeline")),
         "rolled_back_from_version": version,
         "restored_timeline_name": restored_name,
         "archive_of_previous": archive_result,