davinci-resolve-mcp 2.103.5 → 2.104.1

package/CHANGELOG.md

@@ -2,6 +2,88 @@
 
 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.104.1
+
+**The job metadata lies too — verify_output now cross-checks the timeline.**
+Finishing v2.104.0's pending live validation exposed a hole in the new
+`render.verify_output`: in the issue #164 case (content before the timeline
+start) Resolve rewrites the render job's own MarkIn/MarkOut down to the
+collapsed extent. Measured live on Studio 19.1.3.7: 96 frames of content
+placed before the start turned an explicit 96-frame mark range into a 1-frame
+job — Complete at 100%, a 1-frame black stub, and a clean duration ratio,
+because the expected duration was computed from the job's own lying range.
+
+The only truthful readback in that state is the timeline items themselves,
+which report their real positions. `verify_output` now finds the job's
+timeline and cross-checks it: video items starting before the timeline's
+start frame warn (the #164 signature by direct evidence), and a mark range
+under half the items' extent warns (the collapse signature). Callers can also
+pass `expected_frames` or `expected_duration_seconds` outright. Live-verified
+both ways on 19.1.3.7: the healthy render verifies clean, the stub now fails
+with both warnings.
+
+### Fixed
+
+- `render.verify_output` no longer trusts the job's MarkIn/MarkOut as the
+  expected duration — the #164 stub previously verified clean at ratio 1.0.
+
+### Changed
+
+- The api_truth recordFrame entry now documents the mark-range rewrite and
+  the item-readback discriminator; the Blackmagic-facing report regenerated.
+
+## What's New in v2.104.0
+
+The read/write symmetry audit's worklist, worked. PR #162's AST rewrite left
+eight `set_` actions with no readback; live probing on Studio 19.1.3.7 sorted
+them into four the API supports and four it simply cannot — and turned up a
+render-pipeline failure mode along the way.
+
+### Added
+
+- `media_pool.get_clip_marks` — read mark in/out for a set of media-pool clips,
+  the read twin of `set_clip_marks` (live-verified round trip: set 12/60, read
+  12/60).
+- `timeline.get_clips_linked` — per-item link readback via
+  `TimelineItem.GetLinkedItems` (live-verified: a video item returns its audio
+  twin).
+- `timeline.get_title_text` — the read twin of `set_title_text`. Resolves the
+  same heuristic title-property keys as the setter, and falls back to reading
+  `StyledText` off the TextPlus tool in the item's Fusion comp — on Studio
+  19.1.3 the property route exposes no title keys at all (the setter fails
+  there too), while the comp route reads and writes fine.
+- `media_pool_item_markers.get_name` — the markers group carried `set_name`
+  with no read twin.
+- `render.verify_output(job_id)` — checks the actual output file against the
+  job's own mark range: existence, size, ffprobe duration, and a
+  duration-ratio warning when a Complete job produced a near-empty stub (the
+  issue #164 signature: content the render engine never visited). Verify
+  before deleting the job — deleted jobs carry no TargetDir to check.
+
+### Documented (api_truth, Blackmagic-facing report regenerated)
+
+Four readbacks the API cannot express, each now a submit-tagged entry:
+`SetCDL` (no GetCDL anywhere — read grades via DRX decode instead),
+`SetNodeEnabled` (no GetNodeEnabled), `SetKeyframeInterpolation` (nothing
+returns interpolation; the whole keyframe family is absent on 19.1.3), and
+`SetHighPriority` (no getter, irreversible per session). The symmetry report's
+high-signal gap list is now exactly these four.
+
+And one render-pipeline bug found the hard way: **deleting or closing a
+project while its render job is running wedges Resolve** — the orphaned
+render's `IsRenderingInProgress` sticks True on every subsequent project,
+`StopRendering` does not clear it, new render jobs sit at 0% forever, then
+`StartRendering` starts returning False and `Resolve.Quit()` is refused
+behind a quit-confirm dialog. Reproduced live on Studio 19.1.3.7. Poll
+`GetRenderJobStatus` for completion, never `IsRenderingInProgress`, and never
+close a project mid-render.
+
+### Version ledger
+
+`MediaPoolItem.GetMarkInOut` and `TimelineItem.GetLinkedItems` enter the
+evidence gates as measured-present on 19.1.3.7 (introduction versions
+unbisected; the floors err toward refusing on older builds).
+
 ## What's New in v2.103.5
 
 Two fixes that fell out of auditing the code around this week's releases — the

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.103.5-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.104.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-36%20(353%20full)-blue.svg)](#server-modes)

package/README.zh-CN.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 简体中文
 
-[![Version](https://img.shields.io/badge/version-2.103.5-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.104.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-36%20(353%20full)-blue.svg)](#服务器模式)
@@ -12,7 +12,7 @@
 [![Python](https://img.shields.io/badge/python-3.10+-green.svg)](https://www.python.org/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-> 本翻译对应 v2.103.5 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.104.1 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
 
 一个 Model Context Protocol (MCP) 服务器，让 AI 助手通过官方脚本 API 控制 DaVinci Resolve Studio（达芬奇）。它提供完整的 API 覆盖，外加带护栏的工作流助手，涵盖剪辑、媒体池整理、渲染设置、审阅标记、调色、Fusion、Fairlight、项目生命周期任务、扩展开发，以及不碰源媒体的媒体分析。
 

package/docs/reference/api-limitations.md

@@ -12,7 +12,7 @@ that none exists).
 
 **Verified on:** DaVinci Resolve Studio 21.0.2
 
-**Totals:** 29 missing capabilities, 38 bugs / unreliable behaviors.
+**Totals:** 33 missing capabilities, 39 bugs / unreliable behaviors.
 
 The authoritative source is the runtime-queryable `api_truth` ledger
 (`resolve_control api_truth "<query>"`); this document is generated from
@@ -239,6 +239,38 @@ equivalent, blocking full automation.
 - **Workaround / current handling:** Check GetRenderCodecs(format) first; when it is empty, treat the format as unreachable through this API rather than guessing a codec value. Render audio-only via ExportVideo=False on a format that does expose codecs, or drive it from a saved render preset.
 - **Tags:** render, deliver, audio, unsupported
 
+### TimelineItem.SetCDL (write-only — no GetCDL anywhere)
+
+- **Object:** `TimelineItem`
+- **Signature:** `({NodeIndex, Slope, Offset, Power, Saturation}) -> Bool`
+- **Behavior:** SetCDL writes a node's CDL but no object exposes a read: no GetCDL on TimelineItem or Graph in the API reference, and dir() on a live Graph confirms (Studio 19.1.3.7). A grade applied via SetCDL cannot be read back, diffed, or verified through the API.
+- **Workaround / current handling:** Track intended CDL values in the caller, or read the actual grade by exporting a DRX still and decoding it (this repo's drx tool decodes 100% of DRX params — slope/offset/power/sat included).
+- **Tags:** color, missing-method, readback
+
+### Graph.SetNodeEnabled (write-only — no GetNodeEnabled)
+
+- **Object:** `Graph`
+- **Signature:** `(nodeIndex, bool) -> Bool`
+- **Behavior:** A node's bypass state can be set but never read: no GetNodeEnabled in the API reference, and dir() on a live Graph confirms (Studio 19.1.3.7). After a SetNodeEnabled the caller cannot verify it took, and the pre-existing state of a node someone toggled in the UI is unknowable.
+- **Workaround / current handling:** Treat node-enable state as write-only: record what you set, and verify visually (rendered-frame compare) when the state matters.
+- **Tags:** color, missing-method, readback
+
+### TimelineItem.SetKeyframeInterpolation (write-only)
+
+- **Object:** `TimelineItem`
+- **Signature:** `(property, frame, type) -> Bool`
+- **Behavior:** Interpolation can be written per keyframe but nothing returns it: GetKeyframeAtIndex/GetPropertyAtKeyframeIndex expose frame and value only (API reference). On Studio 19.1.3.7 the whole keyframe method family is absent from dir() — these methods are 20.x+.
+- **Workaround / current handling:** Record interpolation choices in the caller; readback is not available at any version.
+- **Tags:** timeline, missing-method, readback, keyframes
+
+### Resolve.SetHighPriority (write-only, irreversible per session)
+
+- **Object:** `Resolve`
+- **Signature:** `() -> Bool`
+- **Behavior:** Raises the Resolve process priority; there is no getter and no way to lower it again through the API (confirmed absent from dir() on Studio 19.1.3.7).
+- **Workaround / current handling:** Call it only when the user asked for a long render on a dedicated machine; state cannot be read back or undone without restarting Resolve.
+- **Tags:** app-control, missing-method, readback
+
 ### TimelineItem.CreateMagicMask (needs operator clicks)
 
 - **Object:** `TimelineItem`
@@ -564,3 +596,11 @@ values, or automation-hostile modal prompts.
 - **Behavior:** The returned TimelineItem objects can have an unreadable/empty GetUniqueId, notably when the clipInfo recordFrame lands in a span still occupied by another item (any duplicate-then-delete 'move' whose offset is smaller than the item duration hits this). The item may not actually exist on the timeline. A session that trusted the non-empty return and deleted the sources lost 26 clips (Portugal timeline, 2026-08-19).
 - **Workaround / current handling:** Never treat AppendToTimeline's return as proof of placement. Re-enumerate the track and match on record frame + duration before any dependent delete; never shift items by duplicate-then-delete into occupied spans — use timeline.ripple_insert, which rebuilds the tail into free space and verifies by readback.
 - **Tags:** editorial, silent-failure, unreliable-return, timeline
+
+### Project.IsRenderingInProgress (stuck True after deleting the rendering project)
+
+- **Object:** `Project`
+- **Signature:** `() -> Bool`
+- **Behavior:** Deleting or closing a project while its render job is still running orphans the render and wedges the whole render pipeline: the output file stops growing and Resolve idles at 0% CPU, IsRenderingInProgress on the NEXT current project reports True indefinitely, StopRendering does not clear it, NEW render jobs sit at 0% forever (then StartRendering starts returning False), and Resolve.Quit() is refused because the app believes a render is running — even project creation can start returning None behind the quit-confirm dialog (reproduced live on Studio 19.1.3.7, 2026-08-29).
+- **Workaround / current handling:** Never close or delete a project while IsRenderingInProgress is True — StopRendering first, wait for False, then close. Once wedged, only a manual quit (confirming the dialog) or force-quit clears it; treat a True that persists at 0% CPU with a static output file as stuck rather than rendering. Poll GetRenderJobStatus for completion instead of IsRenderingInProgress, which this failure poisons.
+- **Tags:** render, silent-failure, unreliable-return

package/docs/reference/readwrite-symmetry.md

@@ -3,19 +3,15 @@
 # Read/Write Symmetry Audit
 
 - write-style action occurrences scanned: **116**
-- write-style action occurrences with a matching read: **67**
-- distinct high-signal `set_` actions without a direct/known readback: **8**
+- write-style action occurrences with a matching read: **71**
+- distinct high-signal `set_` actions without a direct/known readback: **4**
 
 ## High-signal gaps — `set_` with no direct/known readback
 
 - `set_cdl`
-- `set_clip_marks`
-- `set_clips_linked`
 - `set_high_priority`
 - `set_keyframe_interpolation`
-- `set_name`
 - `set_node_enabled`
-- `set_title_text`
 
 ## Low-signal (create/add/insert/apply/import — usually expected): 40 distinct names
 

package/install.py

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

package/package.json

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

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.103.5"
+VERSION = "2.104.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 353-tool granular server instead
 """
 
-VERSION = "2.103.5"
+VERSION = "2.104.1"
 
 import base64
 import os
@@ -5612,6 +5612,76 @@ def _timeline_title_property_scan(tl, p: Dict[str, Any]):
     }
 
 
+def _timeline_get_title_text(tl, p: Dict[str, Any]) -> Dict[str, Any]:
+    """Read a title item's text back — the read twin of set_title_text.
+
+    Same key resolution as the setter: an explicit property_key wins, otherwise
+    the heuristic title-key candidates from the item's property map. Returns the
+    first key that holds a non-empty string, plus every candidate's value so a
+    caller can see which key actually carries the text on this generator.
+    """
+    item, err = _timeline_resolve_item_optional(tl, p)
+    if err:
+        return err
+    property_key = p.get("property_key") or p.get("key")
+    keys: List[str] = []
+    if property_key:
+        keys.append(str(property_key))
+    else:
+        flat, exc_text = _timeline_item_get_property_map(item, _ser)
+        if exc_text and not flat:
+            return _err(f"GetProperty failed: {exc_text}")
+        for row in _candidate_title_property_keys(flat):
+            if row["key"] not in keys:
+                keys.append(row["key"])
+        if not keys:
+            keys = ["Styled Text", "StyledText", "Text", "Rich Text"]
+    values: List[Dict[str, Any]] = []
+    text = None
+    text_key = None
+    for key in keys:
+        rec: Dict[str, Any] = {"property_key": key}
+        try:
+            value = item.GetProperty(key)
+        except Exception as exc:
+            rec["error"] = str(exc)
+            values.append(rec)
+            continue
+        rec["value"] = _ser(value)
+        values.append(rec)
+        if text is None and isinstance(value, str) and value.strip():
+            text = value
+            text_key = key
+    source = "property" if text is not None else None
+    if text is None:
+        # SetProperty/GetProperty title keys are not exposed on every build
+        # (absent for Text+ on Studio 19.1.3, where set_title_text also
+        # fails). The Fusion comp carries the same text as the TextPlus
+        # tool's StyledText input, which reads back fine there — so fall
+        # through to the comp when the property route finds nothing.
+        try:
+            if int(item.GetFusionCompCount() or 0) > 0:
+                comp = item.GetFusionCompByIndex(1)
+                tools = comp.GetToolList(False, "TextPlus") if comp else None
+                for key in (tools or {}):
+                    value = tools[key].GetInput("StyledText")
+                    if isinstance(value, str) and value.strip():
+                        text = value
+                        text_key = "StyledText"
+                        source = "fusion_comp"
+                        break
+        except Exception as exc:
+            values.append({"fusion_comp_error": str(exc)})
+    return {
+        "success": text is not None,
+        "timeline_item_id": _safe_timeline_item_id(item),
+        "text": text,
+        "property_key": text_key,
+        "source": source,
+        "values": values,
+    }
+
+
 def _timeline_set_title_text(tl, p: Dict[str, Any]) -> Dict[str, Any]:
     item, err = _timeline_resolve_item_optional(tl, p)
     if err:
@@ -8634,6 +8704,7 @@ _MEDIA_POOL_KERNEL_ACTIONS = [
     "link_proxy_checked",
     "link_full_resolution_checked",
     "set_clip_marks",
+    "get_clip_marks",
     "clear_clip_marks",
     "copy_clip_annotations",
     "media_pool_boundary_report",
@@ -12843,6 +12914,41 @@ def _clip_media_signature(clip):
     return signature
 
 
+def _ffprobe_media_summary(path: str) -> Optional[Dict[str, Any]]:
+    """Small duration/stream summary of a rendered file; None when ffprobe is unusable."""
+    ffprobe = shutil.which("ffprobe")
+    if not ffprobe:
+        return None
+    try:
+        proc = subprocess.run(
+            [ffprobe, "-v", "error", "-show_entries",
+             "format=duration,size:stream=codec_type,codec_name",
+             "-of", "json", path],
+            capture_output=True, encoding="utf-8", errors="replace",
+            timeout=20, stdin=subprocess.DEVNULL,
+        )
+    except Exception:
+        return None
+    if proc.returncode != 0:
+        return {"error": (proc.stderr or "ffprobe failed").strip()[:300]}
+    try:
+        payload = json.loads(proc.stdout or "{}")
+    except ValueError:
+        return None
+    fmt = payload.get("format") or {}
+    summary: Dict[str, Any] = {
+        "streams": [
+            {"codec_type": st.get("codec_type"), "codec_name": st.get("codec_name")}
+            for st in payload.get("streams") or []
+        ],
+    }
+    try:
+        summary["duration_seconds"] = float(fmt.get("duration"))
+    except (TypeError, ValueError):
+        summary["duration_seconds"] = None
+    return summary
+
+
 def _probe_media_file(path: str):
     ffprobe = shutil.which("ffprobe")
     if not ffprobe:
@@ -13371,6 +13477,23 @@ def _set_clip_marks(root, mp, p: Dict[str, Any]):
     return {"success": all(row.get("success") for row in results), "count": len(results), "missing": missing, "results": results}
 
 
+def _get_clip_marks(root, mp, p: Dict[str, Any]):
+    """Read mark in/out for a set of media-pool clips — the read twin of set_clip_marks."""
+    resolved, err = _clips_from_params(root, mp, p)
+    if err:
+        return err
+    clips, missing = resolved
+    results = []
+    for clip in clips:
+        clip_id = _safe_media_pool_item_id(clip)
+        gate = _requires_method(clip, "GetMarkInOut", "19.1")
+        if gate:
+            return gate
+        marks = clip.GetMarkInOut() or {}
+        results.append({"clip_id": clip_id, "name": clip.GetName(), "marks": _ser(marks)})
+    return {"success": True, "count": len(results), "missing": missing, "results": results}
+
+
 def _clear_clip_marks(root, mp, p: Dict[str, Any]):
     resolved, err = _clips_from_params(root, mp, p)
     if err:
@@ -18457,6 +18580,16 @@ def render(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
       delete_all_jobs() -> {success}
       list_jobs() -> {jobs}
       get_job_status(job_id) -> {status}
+      verify_output(job_id, expected_frames?, expected_duration_seconds?) -> {status, output_path, output_exists, output_size_bytes, output_probe, mark_range_frames, timeline_item_extent_frames, expected_duration_seconds, duration_ratio, warnings, verified}
+        JobStatus reports Complete even when the render produced a near-empty
+        stub (content before the timeline start, issue #164), and Resolve
+        rewrites the job's own MarkIn/MarkOut down to the collapsed extent, so
+        the job metadata lies too. This checks the actual output file, and
+        cross-checks the job's timeline items (which read back their real
+        positions): items before the timeline start and a mark range far
+        smaller than the item extent both warn. Pass expected_frames or
+        expected_duration_seconds when you know what the render should hold.
+        Verify BEFORE deleting the job; deleted jobs carry no TargetDir.
       start(job_ids?, interactive?) -> {success}
       stop() -> {success}
       is_rendering() -> {rendering}
@@ -18521,6 +18654,143 @@ def render(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
         return {"jobs": _ser(proj.GetRenderJobList())}
     elif action == "get_job_status":
         return _ser(proj.GetRenderJobStatus(p["job_id"]))
+    elif action == "verify_output":
+        # JobStatus lies by omission: a job whose content renders as nothing
+        # (e.g. clips placed before the timeline start, issue #164) still
+        # reports Complete at 100% with a stub output file. Verify the file.
+        job_id = p.get("job_id")
+        if not job_id:
+            return _err("verify_output requires job_id")
+        status = _ser(proj.GetRenderJobStatus(job_id)) or {}
+        jobs = _ser(proj.GetRenderJobList()) or []
+        job = next((j for j in jobs if j.get("JobId") == job_id), None)
+        if job is None:
+            return _err(
+                f"Render job {job_id!r} is not in the render queue "
+                "(deleted jobs cannot be verified — verify before deleting)",
+                code="JOB_NOT_FOUND", category="invalid_input",
+            )
+        result: Dict[str, Any] = {"job_id": job_id, "status": status}
+        target_dir = job.get("TargetDir")
+        filename = job.get("OutputFilename")
+        warnings: List[str] = []
+        output_path = None
+        if target_dir and filename:
+            output_path = os.path.join(target_dir, filename)
+        else:
+            warnings.append("Job carries no TargetDir/OutputFilename to verify against.")
+        result["output_path"] = output_path
+        # The job's own MarkIn/MarkOut cannot be the only truth source: when
+        # timeline content sits before the timeline's start frame (issue #164)
+        # Resolve rewrites the job's mark range down to the collapsed extent,
+        # so the job metadata lies right along with JobStatus (measured live on
+        # Studio 19.1.3.7: 96 frames of content before start -> job range of 1
+        # frame, Complete at 100%, a 1-frame black stub). Cross-check the
+        # job's timeline items, which DO read back their real positions, and
+        # let the caller override expected duration outright.
+        try:
+            fps = float(str(job.get("FrameRate")))
+        except (TypeError, ValueError):
+            fps = None
+        try:
+            mark_frames = int(job.get("MarkOut")) - int(job.get("MarkIn")) + 1
+        except (TypeError, ValueError):
+            mark_frames = None
+        result["mark_range_frames"] = mark_frames
+        tl_for_job = None
+        try:
+            for i in range(1, int(proj.GetTimelineCount() or 0) + 1):
+                cand = proj.GetTimelineByIndex(i)
+                if cand and cand.GetName() == job.get("TimelineName"):
+                    tl_for_job = cand
+                    break
+        except Exception:
+            tl_for_job = None
+        if tl_for_job is not None:
+            try:
+                tl_start = int(tl_for_job.GetStartFrame())
+                extent_lo, extent_hi, before_start = None, None, 0
+                for ti in range(1, int(tl_for_job.GetTrackCount("video") or 0) + 1):
+                    for it in tl_for_job.GetItemListInTrack("video", ti) or []:
+                        it_start, it_end = int(it.GetStart()), int(it.GetEnd())
+                        extent_lo = it_start if extent_lo is None else min(extent_lo, it_start)
+                        extent_hi = it_end if extent_hi is None else max(extent_hi, it_end)
+                        if it_start < tl_start:
+                            before_start += 1
+                if before_start:
+                    warnings.append(
+                        f"{before_start} video item(s) on timeline "
+                        f"{job.get('TimelineName')!r} start before the timeline's "
+                        f"start frame {tl_start} — the render engine never visits "
+                        "that content (recordFrame counts from absolute frame "
+                        "zero, issue #164). The items read back as placed; the "
+                        "render is a stub."
+                    )
+                if (extent_lo is not None and mark_frames is not None
+                        and mark_frames < (extent_hi - extent_lo) * 0.5):
+                    warnings.append(
+                        f"The job's mark range ({mark_frames} frame(s)) is under "
+                        f"half the timeline's item extent "
+                        f"({extent_hi - extent_lo} frames) — Resolve rewrote the "
+                        "range down to a collapsed extent, which is how a stub "
+                        "render reports a clean duration ratio."
+                    )
+                result["timeline_item_extent_frames"] = (
+                    None if extent_lo is None else extent_hi - extent_lo
+                )
+            except Exception:
+                pass
+        else:
+            warnings.append(
+                f"Timeline {job.get('TimelineName')!r} was not found in the "
+                "project, so item-extent cross-checks were skipped."
+            )
+        if output_path:
+            exists = os.path.exists(output_path)
+            result["output_exists"] = exists
+            if exists:
+                result["output_size_bytes"] = os.path.getsize(output_path)
+                probe = _ffprobe_media_summary(output_path)
+                if probe:
+                    result["output_probe"] = probe
+                    duration = probe.get("duration_seconds")
+                    # Expected duration: caller-supplied truth wins; the job's
+                    # mark range is the fallback (see collapse caveat above).
+                    expected = None
+                    if p.get("expected_duration_seconds") is not None:
+                        try:
+                            expected = float(p["expected_duration_seconds"])
+                        except (TypeError, ValueError):
+                            expected = None
+                    elif p.get("expected_frames") is not None and fps:
+                        try:
+                            expected = int(p["expected_frames"]) / fps
+                        except (TypeError, ValueError):
+                            expected = None
+                    elif mark_frames is not None and fps:
+                        expected = mark_frames / fps
+                    result["expected_duration_seconds"] = expected
+                    if duration is not None and expected and expected > 0:
+                        result["duration_ratio"] = round(duration / expected, 4)
+                        if duration < expected * 0.5:
+                            warnings.append(
+                                f"Output duration {duration:.2f}s is under half the job's "
+                                f"mark range ({expected:.2f}s). A Complete status with a "
+                                "near-empty file is the signature of content the render "
+                                "engine never visited — e.g. clips placed before the "
+                                "timeline start (recordFrame counted from absolute zero, "
+                                "issue #164)."
+                            )
+            else:
+                if status.get("JobStatus") == "Complete":
+                    warnings.append(
+                        "JobStatus is Complete but the output file does not exist."
+                    )
+        result["warnings"] = warnings
+        result["verified"] = bool(
+            output_path and result.get("output_exists") and not warnings
+        )
+        return result
     elif action == "start":
         job_ids = p.get("job_ids")
         interactive = p.get("interactive", False)
@@ -18645,7 +18915,7 @@ def render(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
         return _safe_quick_export(proj, p)
     elif action == "export_render_boundary_report":
         return _export_render_boundary_report(proj, p)
-    return _unknown(action, ["add_job","delete_job","delete_all_jobs","list_jobs","get_job_status","start","stop","is_rendering","get_formats","get_codecs","get_format_and_codec","set_format_and_codec","get_mode","set_mode","get_resolutions","get_settings","set_settings","list_presets","load_preset","save_preset","delete_preset","quick_export_presets","quick_export",*_RENDER_KERNEL_ACTIONS])
+    return _unknown(action, ["add_job","delete_job","delete_all_jobs","list_jobs","get_job_status","verify_output","start","stop","is_rendering","get_formats","get_codecs","get_format_and_codec","set_format_and_codec","get_mode","set_mode","get_resolutions","get_settings","set_settings","list_presets","load_preset","save_preset","delete_preset","quick_export_presets","quick_export",*_RENDER_KERNEL_ACTIONS])
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -19185,6 +19455,8 @@ def media_pool(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str
         return _link_full_resolution_checked(root, p)
     elif action == "set_clip_marks":
         return _set_clip_marks(root, mp, p)
+    elif action == "get_clip_marks":
+        return _get_clip_marks(root, mp, p)
     elif action == "clear_clip_marks":
         return _clear_clip_marks(root, mp, p)
     elif action == "copy_clip_annotations":
@@ -19854,6 +20126,8 @@ def media_pool_item_markers(action: str, params: Optional[Dict[str, Any]] = None
         return {"flags": clip.GetFlagList()}
     elif action == "clear_flags":
         return {"success": bool(clip.ClearFlags(p["color"]))}
+    elif action == "get_name":
+        return {"name": clip.GetName()}
     elif action == "set_name":
         missing = _requires_method(clip, "SetName", "20.2")
         if missing:
@@ -19880,7 +20154,7 @@ def media_pool_item_markers(action: str, params: Optional[Dict[str, Any]] = None
         if not replacement_path:
             return _err("Provide path or file_path")
         return {"success": bool(clip.ReplaceClipPreserveSubClip(replacement_path))}
-    return _unknown(action, ["add","get_all","get_by_custom_data","update_custom_data","get_custom_data","delete_by_color","delete_at_frame","delete_by_custom_data","add_flag","get_flags","clear_flags","set_name","link_full_resolution_media","monitor_growing_file","replace_clip_preserve_sub_clip"])
+    return _unknown(action, ["add","get_all","get_by_custom_data","update_custom_data","get_custom_data","delete_by_color","delete_at_frame","delete_by_custom_data","add_flag","get_flags","clear_flags","get_name","set_name","link_full_resolution_media","monitor_growing_file","replace_clip_preserve_sub_clip"])
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -22924,7 +23198,8 @@ _TIMELINE_ACTIONS = [
     "overwrite_range", "lift_range", "story_spine_report", "create_variant_from_ranges",
     "bulk_set_item_properties", "apply_look_to_items", "thumbnail_contact_sheet",
     "marker_thumbnail_review", "edit_kernel_capabilities", "probe_edit_kernel_item",
-    "title_property_scan", "set_title_text", "bulk_set_title_text", "create_compound_clip",
+    "title_property_scan", "set_title_text", "get_title_text", "get_clips_linked",
+    "bulk_set_title_text", "create_compound_clip",
     "create_fusion_clip", "import_into_timeline", "export", "get_setting", "set_setting",
     "insert_generator", "insert_fusion_generator", "insert_fusion_composition",
     "insert_ofx_generator", "insert_title", "insert_fusion_title", "get_unique_id",
@@ -23418,6 +23693,29 @@ def timeline(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str,
         return _timeline_title_property_scan(tl, p)
     elif action == "set_title_text":
         return _timeline_set_title_text(tl, p)
+    elif action == "get_title_text":
+        return _timeline_get_title_text(tl, p)
+    elif action == "get_clips_linked":
+        ids = p.get("clip_ids") or ([p["clip_id"]] if p.get("clip_id") else None)
+        if not ids:
+            return _err("get_clips_linked requires clip_id or clip_ids")
+        groups = []
+        for cid in ids:
+            it = _find_timeline_item_by_id(tl, cid)
+            if not it:
+                groups.append({"clip_id": cid, "error": "not found"})
+                continue
+            missing = _requires_method(it, "GetLinkedItems", "19.1")
+            if missing:
+                return missing
+            linked = it.GetLinkedItems() or []
+            groups.append({
+                "clip_id": cid,
+                "name": it.GetName(),
+                "linked": bool(linked),
+                "linked_items": [{"name": li.GetName(), "id": li.GetUniqueId()} for li in linked],
+            })
+        return {"groups": groups, "count": len(groups)}
     elif action == "bulk_set_title_text":
         return _timeline_bulk_set_title_text(tl, p)
     elif action == "create_compound_clip":

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,
     },
@@ -2267,6 +2279,90 @@ API_TRUTH: List[Dict[str, Any]] = [
         "mitigation": ["_append_and_recover_timeline_item duplicate_verified gate",
                        "_timeline_ripple_insert_impl"],
     },
+    {
+        "symbol": "TimelineItem.SetCDL (write-only — no GetCDL anywhere)",
+        "object": "TimelineItem",
+        "signature": "({NodeIndex, Slope, Offset, Power, Saturation}) -> Bool",
+        "reality": "SetCDL writes a node's CDL but no object exposes a read: "
+                   "no GetCDL on TimelineItem or Graph in the API reference, "
+                   "and dir() on a live Graph confirms (Studio 19.1.3.7). A "
+                   "grade applied via SetCDL cannot be read back, diffed, or "
+                   "verified through the API.",
+        "recommended": "Track intended CDL values in the caller, or read the "
+                       "actual grade by exporting a DRX still and decoding it "
+                       "(this repo's drx tool decodes 100% of DRX params — "
+                       "slope/offset/power/sat included).",
+        "tags": ["color", "missing-method", "readback"],
+        "submit": "missing",
+    },
+    {
+        "symbol": "Graph.SetNodeEnabled (write-only — no GetNodeEnabled)",
+        "object": "Graph",
+        "signature": "(nodeIndex, bool) -> Bool",
+        "reality": "A node's bypass state can be set but never read: no "
+                   "GetNodeEnabled in the API reference, and dir() on a live "
+                   "Graph confirms (Studio 19.1.3.7). After a SetNodeEnabled "
+                   "the caller cannot verify it took, and the pre-existing "
+                   "state of a node someone toggled in the UI is unknowable.",
+        "recommended": "Treat node-enable state as write-only: record what "
+                       "you set, and verify visually (rendered-frame compare) "
+                       "when the state matters.",
+        "tags": ["color", "missing-method", "readback"],
+        "submit": "missing",
+    },
+    {
+        "symbol": "TimelineItem.SetKeyframeInterpolation (write-only)",
+        "object": "TimelineItem",
+        "signature": "(property, frame, type) -> Bool",
+        "reality": "Interpolation can be written per keyframe but nothing "
+                   "returns it: GetKeyframeAtIndex/GetPropertyAtKeyframeIndex "
+                   "expose frame and value only (API reference). On Studio "
+                   "19.1.3.7 the whole keyframe method family is absent from "
+                   "dir() — these methods are 20.x+.",
+        "recommended": "Record interpolation choices in the caller; readback "
+                       "is not available at any version.",
+        "tags": ["timeline", "missing-method", "readback", "keyframes"],
+        "submit": "missing",
+    },
+    {
+        "symbol": "Resolve.SetHighPriority (write-only, irreversible per session)",
+        "object": "Resolve",
+        "signature": "() -> Bool",
+        "reality": "Raises the Resolve process priority; there is no getter "
+                   "and no way to lower it again through the API (confirmed "
+                   "absent from dir() on Studio 19.1.3.7).",
+        "recommended": "Call it only when the user asked for a long render on "
+                       "a dedicated machine; state cannot be read back or "
+                       "undone without restarting Resolve.",
+        "tags": ["app-control", "missing-method", "readback"],
+        "submit": "missing",
+    },
+    {
+        "symbol": "Project.IsRenderingInProgress (stuck True after deleting the rendering project)",
+        "object": "Project",
+        "signature": "() -> Bool",
+        "reality": "Deleting or closing a project while its render job is "
+                   "still running orphans the render and wedges the whole "
+                   "render pipeline: the output file stops growing and "
+                   "Resolve idles at 0% CPU, IsRenderingInProgress on the "
+                   "NEXT current project reports True indefinitely, "
+                   "StopRendering does not clear it, NEW render jobs sit at "
+                   "0% forever (then StartRendering starts returning False), "
+                   "and Resolve.Quit() is refused because the app believes a "
+                   "render is running — even project creation can start "
+                   "returning None behind the quit-confirm dialog "
+                   "(reproduced live on Studio 19.1.3.7, 2026-08-29).",
+        "recommended": "Never close or delete a project while "
+                       "IsRenderingInProgress is True — StopRendering first, "
+                       "wait for False, then close. Once wedged, only a "
+                       "manual quit (confirming the dialog) or force-quit "
+                       "clears it; treat a True that persists at 0% CPU with "
+                       "a static output file as stuck rather than rendering. "
+                       "Poll GetRenderJobStatus for completion instead of "
+                       "IsRenderingInProgress, which this failure poisons.",
+        "tags": ["render", "silent-failure", "unreliable-return"],
+        "submit": "bug",
+    },
     {
         "symbol": "TimelineItem.CreateMagicMask (needs operator clicks)",
         "object": "TimelineItem",

package/src/utils/resolve_versions.py

@@ -118,6 +118,23 @@ _EVIDENCE_GATES: List[Dict[str, Any]] = [
                 "workaround is unavailable.",
         "issue": 128,
     },
+    {
+        "symbol": "MediaPoolItem.GetMarkInOut",
+        "introduced_in": "19.1",
+        "source": "measured",
+        "note": "Present on Studio 19.1.3.7 (confirmed live 2026-08-29, "
+                "set/get round trip). Introduction version not bisected — "
+                "19.1 is the highest floor this repo can attest, so older "
+                "builds may have it too and the gate errs toward refusing.",
+    },
+    {
+        "symbol": "TimelineItem.GetLinkedItems",
+        "introduced_in": "19.1",
+        "source": "measured",
+        "note": "Present on Studio 19.1.3.7 (confirmed live 2026-08-29, "
+                "returned the audio twin of a video item). Introduction "
+                "version not bisected — same caveat as GetMarkInOut.",
+    },
     {
         # Named on Project, not Timeline: the shipped README lists it in the
         # Project section and src/server.py calls it on the project handle. The