davinci-resolve-mcp 2.103.4 → 2.104.0

package/CHANGELOG.md

@@ -2,6 +2,106 @@
 
 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.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
+same failure classes as #161 and #164, found one tier up from where each was
+originally fixed.
+
+**Cache reuse was permanently poisoned on most real installs.** The v2.103.3
+transcription fix taught batch jobs that a declined transcription is not a clip
+failure — but the cache layer had the same default-ON blindness.
+`_report_missing_layers` counted any non-success transcript as a missing layer,
+and the capability gate only screens for a missing backend, not for the stock
+configuration: Whisper installed, `allow_model_download` unset. On such a
+machine every analysis writes a declined "skipped" transcript, every cached
+report carries `missing_layers: ['transcription']`, and `find_reusable_report`
+returns `reusable: False` — forever. Every analyze call silently re-ran full
+analysis (frame extraction included) and produced the same skipped transcript
+again. An unfixable loop, reproduced end-to-end before the fix and green after.
+
+A transcript-less report is now a missing layer only when a re-run could supply
+the transcript: the cached payload shows a real attempt that failed (a timeout
+retry may succeed), or the current options would now actually run a backend
+(mock or HTTP backends, or `allow_model_download=true`). Because the check is
+recomputed per request, flipping `allow_model_download` on later correctly
+refuses reuse and finally produces the transcript.
+
+**Absolute recordFrames below the timeline start are now refused.** Issue #164
+documented that `recordFrame` counts from Resolve's global frame zero and that
+content placed before the timeline start reads back correctly while rendering
+as ~0 frames. The wrapper's `record_frame_mode='relative'` default shields
+callers — but `record_frame_mode='absolute'` passed any value straight through,
+so an absolute-mode caller with relative-style values reproduced the silent
+stub through this server's own tools. `_normalize_record_frame` (both the
+compound and granular copies) now rejects an absolute value below the
+timeline's start frame with an error naming the convention; internal
+absolute-mode flows (`ripple_insert` cursors) derive their frames from
+timeline reads and cannot trip it. The Resolve UI cannot place content there,
+so no legitimate call is lost.
+
+### Fixed
+
+- A declined transcription (no `allow_model_download` opt-in, unavailable or
+  not-implemented backend) no longer marks cached analysis reports
+  incomplete, so report reuse works on default installs again. Opting into
+  model downloads later invalidates reuse and produces the transcript.
+- `record_frame_mode='absolute'` values below the timeline start frame are
+  refused with a remediation instead of silently placing content the render
+  engine never visits (#164).
+
 ## What's New in v2.103.4
 
 **A frame-numbering trap, documented where agents will look it up.** Issue #164

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-2.103.4-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.104.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-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.4-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.104.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-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.4 版 README。如与英文原版有出入，以 [英文原版](README.md) 为准。
+> 本翻译对应 v2.104.0 版 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.4"
+VERSION = "2.104.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.103.4",
+  "version": "2.104.0",
   "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.4"
+VERSION = "2.104.0"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")
@@ -572,7 +572,22 @@ def _normalize_record_frame(ci, index, timeline_start_frame=None):
         }
 
     start = _frame_int(timeline_start_frame)
-    if start in (None, 0) or mode == "absolute":
+    if mode == "absolute":
+        # recordFrame counts from Resolve's global frame zero; a value below
+        # the timeline start renders as ~0 frames while every readback agrees
+        # (issue #164). No legitimate placement exists there — refuse.
+        if start not in (None, 0) and rf < start:
+            return None, {
+                "error": (
+                    f"clip_infos[{index}] recordFrame {rf} is before the timeline "
+                    f"start frame {start}. recordFrame is timeline-absolute, so "
+                    "content placed there reads back correctly but renders as ~0 "
+                    "frames. Use record_frame_mode='relative' (default) or pass an "
+                    f"absolute frame >= {start}."
+                )
+            }
+        return rf, None
+    if start in (None, 0):
         return rf, None
     if mode == "auto":
         return (start + rf) if rf < start else rf, None

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 353-tool granular server instead
 """
 
-VERSION = "2.103.4"
+VERSION = "2.104.0"
 
 import base64
 import os
@@ -2894,7 +2894,24 @@ def _normalize_record_frame(
         )
 
     start = _frame_int(timeline_start_frame)
-    if start in (None, 0) or mode == "absolute":
+    if mode == "absolute":
+        # recordFrame counts from Resolve's global frame zero. An absolute
+        # value below the timeline's own start frame places content the render
+        # engine never visits: every readback agrees, the render reports
+        # Complete, and the output is a near-empty stub (issue #164; see the
+        # api_truth recordFrame timeline-absolute origin entry). The Resolve UI
+        # cannot place content there, so there is no legitimate case — refuse.
+        if start not in (None, 0) and rf < start:
+            return None, _err(
+                f"clip_infos[{index}] recordFrame {rf} is before the timeline start "
+                f"frame {start}. recordFrame is timeline-absolute (counted from frame "
+                "zero, not from the timeline's start), so content placed there reads "
+                "back correctly but renders as ~0 frames. Use the default "
+                "record_frame_mode='relative' with an offset from the timeline start, "
+                f"or pass an absolute frame >= {start}."
+            )
+        return rf, None
+    if start in (None, 0):
         return rf, None
     if mode == "auto":
         return (start + rf) if rf < start else rf, None
@@ -5595,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:
@@ -8617,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",
@@ -12826,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:
@@ -13354,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:
@@ -18440,6 +18580,11 @@ 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) -> {status, output_path, output_exists, output_size_bytes, output_probe, 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) — this checks the
+        actual output file against the job's mark range. Verify BEFORE deleting
+        the job; deleted jobs carry no TargetDir to check.
       start(job_ids?, interactive?) -> {success}
       stop() -> {success}
       is_rendering() -> {rendering}
@@ -18504,6 +18649,70 @@ 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
+        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 from the job's own mark range and rate.
+                    try:
+                        frames = int(job.get("MarkOut")) - int(job.get("MarkIn")) + 1
+                        fps = float(str(job.get("FrameRate")))
+                        expected = frames / fps if fps > 0 else None
+                    except (TypeError, ValueError):
+                        expected = None
+                    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)
@@ -18628,7 +18837,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])
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -19168,6 +19377,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":
@@ -19837,6 +20048,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:
@@ -19863,7 +20076,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"])
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -22907,7 +23120,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",
@@ -23401,6 +23615,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

@@ -1884,7 +1884,9 @@ API_TRUTH: List[Dict[str, Any]] = [
                        "media_pool.append_to_timeline defaults to "
                        "record_frame_mode='relative' and adds the start frame, "
                        "so pass record_frame_mode='absolute' only for raw "
-                       "Resolve frame numbers. When driving the API directly, "
+                       "Resolve frame numbers — and since v2.103.5 an absolute "
+                       "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.",
@@ -2265,6 +2267,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/media_analysis.py

@@ -227,6 +227,30 @@ def transcription_attempt_failed(transcript: Any, *, enabled: bool) -> bool:
     return status not in TRANSCRIPTION_UNATTEMPTED_STATUSES
 
 
+def transcription_options_would_attempt(transcription: Dict[str, Any]) -> bool:
+    """True when these options would actually run a transcription backend.
+
+    Mirrors _transcribe's early-outs. The local backends (whisper_cli,
+    mlx_whisper — also what a backend of None resolves to) refuse to run
+    without allow_model_download=true, whisper_cpp is not_implemented, and
+    the resolve backend is refused by design; mock and HTTP-provider
+    backends always attempt. Used by _report_missing_layers to decide
+    whether re-running an analysis could produce a transcript a cached
+    report lacks — if it could not, the cached report is as complete as a
+    fresh run would be. Known blind spot: backend None on a machine whose
+    only configured backend is an HTTP provider reports False here; name
+    the http_* backend explicitly to get cache invalidation.
+    """
+    backend = transcription.get("backend")
+    if backend in {"mock", "local_mock"}:
+        return True
+    if isinstance(backend, str) and backend.startswith(HTTP_TRANSCRIPTION_BACKEND_PREFIX):
+        return True
+    if backend in {"whisper_cpp", "resolve"}:
+        return False
+    return _coerce_bool(transcription.get("allow_model_download"), default=False)
+
+
 def _annotate_clip_transcript_failure(clip_result: Dict[str, Any], transcript: Any) -> None:
     """Mark a clip failed when requested transcription did not complete.
 
@@ -3665,7 +3689,19 @@ def _report_missing_layers(report: Dict[str, Any], depth: str, options: Dict[str
     if _coerce_bool(transcription.get("enabled"), default=DEFAULT_TRANSCRIPTION_ENABLED):
         transcript = report.get("transcription") or {}
         if not transcript.get("success") or transcript.get("status") == "skipped":
-            missing.append("transcription")
+            # A transcript-less report is a missing layer only when a re-run
+            # could supply the transcript: either the cached payload shows a
+            # real attempt that failed (a retry may fix a timeout), or the
+            # current options would now actually run a backend. Transcription
+            # is enabled by default while allow_model_download is not, so on a
+            # stock install every report carries a declined "skipped" payload —
+            # counting that as missing made every cached report reusable=False
+            # forever, silently defeating cache reuse with full re-analysis
+            # that could never produce the transcript either.
+            if transcription_attempt_failed(
+                transcript, enabled=True
+            ) or transcription_options_would_attempt(transcription):
+                missing.append("transcription")
     vision = options.get("vision") or {}
     if _coerce_bool(vision.get("enabled"), default=False):
         visual = report.get("visual") or {}

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