davinci-resolve-mcp 2.59.0 → 2.61.0

package/src/utils/analysis_store.py

@@ -335,9 +335,15 @@ def ingest_report(
             "SELECT created_at FROM clips WHERE clip_uuid = ?", (clip_uuid,)
         ).fetchone()
         created_at = str(existing["created_at"]) if existing else now
+        # True upsert — never INSERT OR REPLACE: REPLACE deletes the existing
+        # row first, and with PRAGMA foreign_keys=ON that cascade-deletes every
+        # child table (events/curves/transcript_words/story_beats included),
+        # wiping strata rows — human annotations among them — on every
+        # re-ingest. The v13 strata tables are NOT rebuilt by ingest, so the
+        # clips row must be updated in place.
         conn.execute(
             """
-            INSERT OR REPLACE INTO clips
+            INSERT INTO clips
                 (clip_uuid, clip_dir, resolve_clip_id, media_id, clip_name,
                  file_path, bin_path, duration_seconds, fps, resolution,
                  media_type, summary, overall_motion_level, cut_count,
@@ -345,6 +351,28 @@ def ingest_report(
                  analyzed_at, vision_status, vision_committed_at,
                  created_at, updated_at)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(clip_uuid) DO UPDATE SET
+                clip_dir=excluded.clip_dir,
+                resolve_clip_id=excluded.resolve_clip_id,
+                media_id=excluded.media_id,
+                clip_name=excluded.clip_name,
+                file_path=excluded.file_path,
+                bin_path=excluded.bin_path,
+                duration_seconds=excluded.duration_seconds,
+                fps=excluded.fps,
+                resolution=excluded.resolution,
+                media_type=excluded.media_type,
+                summary=excluded.summary,
+                overall_motion_level=excluded.overall_motion_level,
+                cut_count=excluded.cut_count,
+                shot_count=excluded.shot_count,
+                analysis_version=excluded.analysis_version,
+                depth=excluded.depth,
+                signature_hash=excluded.signature_hash,
+                analyzed_at=excluded.analyzed_at,
+                vision_status=excluded.vision_status,
+                vision_committed_at=excluded.vision_committed_at,
+                updated_at=excluded.updated_at
             """,
             (
                 clip_uuid,
@@ -473,6 +501,12 @@ def ingest_report(
                 ),
             )
 
+        # Word-level timestamps (v13): promote segments[*].words to rows so
+        # word-boundary queries never have to parse the report blob.
+        from src.utils import strata as _strata
+
+        words_written = _strata.ingest_transcript_words(conn, clip_uuid, transcription)
+
         # Sampled frames. Shot mapping uses frame_indices_used when present,
         # with a time-containment fallback (some commit paths don't record
         # which frame indices fed which shot).
@@ -576,6 +610,7 @@ def ingest_report(
         "shot_count": len(shot_entries),
         "subjective_fields_written": subj_written,
         "subjective_fields_preserved_human": subj_skipped_human,
+        "transcript_words_written": words_written,
     }
 
 

package/src/utils/api_truth.py

@@ -355,6 +355,38 @@ API_TRUTH: List[Dict[str, Any]] = [
         "tags": ["missing-method", "timeline", "edit"],
         "submit": "missing",
     },
+    {
+        "symbol": "Render in Place / bake a timeline clip to new media",
+        "object": "Timeline / TimelineItem / MediaPool",
+        "reality": "There is no scripting method for the Edit-page clip "
+                   "context-menu action 'Render in Place', which bakes a clip "
+                   "(including its Fusion composition and effects) into a NEW "
+                   "rendered media file and drops that file back on the timeline "
+                   "at the same position, replacing the source clip. No "
+                   "Render*/Bake*/Freeze* method exists on Timeline, TimelineItem "
+                   "or MediaPool in the Resolve scripting API reference (BMD docs) "
+                   "or a dir() audit. NOTE the frequently-confused-but-distinct "
+                   "sibling: the render *cache* (a temporary, non-destructive "
+                   "cache of a clip's Color/Fusion output that reduces playback "
+                   "load WITHOUT creating a new media file) IS scriptable — "
+                   "TimelineItem.SetColorOutputCache / SetFusionOutputCache "
+                   "('Render Cache Color/Fusion Output' menu actions) and "
+                   "Graph.SetNodeCacheMode. Render in Place is the permanent, "
+                   "media-producing bake; the render cache is the transient one.",
+        "recommended": "If the goal is only to reduce playback/render load, use "
+                       "the render cache — exposed as timeline_item "
+                       "get_color_cache/set_color_cache/get_fusion_cache/"
+                       "set_fusion_cache and the Color-page graph node cache_mode "
+                       "(no new media, fully reversible). If you genuinely need a "
+                       "baked media file, render the clip's in/out range from the "
+                       "Deliver page (proj.AddRenderJob with MarkIn/MarkOut) and "
+                       "relink/append the result yourself, or run Render in Place "
+                       "from the Resolve UI. There is no one-call API equivalent. "
+                       "See issue #86.",
+        "tags": ["missing-method", "timeline", "render", "cache", "render-in-place", "bake"],
+        "submit": "missing",
+        "issue": 86,
+    },
     {
         "symbol": "Smart Bins / Power Bins creation",
         "object": "MediaPool",
@@ -508,6 +540,30 @@ API_TRUTH: List[Dict[str, Any]] = [
                        "pass-through.",
         "tags": ["silent-failure", "color", "node-graph", "layout", "drx"],
     },
+    {
+        "symbol": "MediaPool.AppendToTimeline clipInfo endFrame (exclusive bound)",
+        "object": "MediaPool",
+        "signature": "([{mediaPoolItem, startFrame, endFrame, recordFrame, "
+                     "trackIndex, mediaType}]) -> [TimelineItem]",
+        "reality": "clipInfo endFrame is an EXCLUSIVE bound: the appended item's "
+                   "duration is endFrame - startFrame frames, not "
+                   "endFrame - startFrame + 1. Verified by readback probe on "
+                   "Resolve Studio 21.0 — appending {startFrame: 6254, "
+                   "endFrame: 6348} yields a 94-frame item, and 130 such "
+                   "appends whose absolute recordFrames advance by exactly "
+                   "(endFrame - startFrame) assemble a gap-free track whose "
+                   "total length equals the sum of (end - start). Code that "
+                   "assumes an inclusive bound drifts one frame per clip: "
+                   "advancing a record cursor by (end - start + 1) leaves a "
+                   "1-frame hole between consecutive clips, and converting a "
+                   "half-open range with (end - 1) shaves the range's last "
+                   "frame.",
+        "recommended": "Treat [startFrame, endFrame) as half-open everywhere: "
+                       "duration = endFrame - startFrame; next recordFrame = "
+                       "previous recordFrame + duration; no ±1 corrections "
+                       "when mirroring keep-ranges into clipInfos.",
+        "tags": ["timeline", "edit", "off-by-one", "readback"],
+    },
 ]
 
 

package/src/utils/destructive_hook.py

@@ -99,7 +99,10 @@ DESTRUCTIVE_ACTIONS_BY_TOOL: Dict[str, FrozenSet[str]] = {
         "set_track_enable",
         "set_track_name",
         "set_voice_isolation_state",
-        "set_name",
+        # NOTE: timeline.set_name (rename) is intentionally NOT here. A rename is
+        # content-preserving and trivially reversible, so version-on-mutate added
+        # no recovery value — it only spawned redundant `_archived` copies (one per
+        # rename, and renaming an archive archived the archive). Issue #83.
         "set_start_timecode",
         "set_setting",
         "set_mark_in_out",

package/src/utils/edit_engine.py

@@ -262,7 +262,10 @@ def plan_selects(
         if isinstance(clip_duration, (int, float)) and clip_duration:
             src_end = min(src_end, float(clip_duration))
         start_frame = int(round(src_start * fps))
-        end_frame = max(start_frame + 1, int(round(src_end * fps)) - 1)
+        # AppendToTimeline clipInfo endFrame is a half-open (exclusive) bound —
+        # duration = endFrame - startFrame. See api_truth "AppendToTimeline
+        # clipInfo endFrame". No -1: that would shave the last frame of every select.
+        end_frame = max(start_frame + 1, int(round(src_end * fps)))
         decision = {k: v for k, v in candidate.items() if not k.startswith("_")}
         decision["source_frame_range"] = [start_frame, end_frame]
         decisions.append(decision)
@@ -339,6 +342,29 @@ def _gaps_in_range(
     return gaps
 
 
+def _dedupe_skipped(skipped: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Collapse identical (item, reason) skip rows into one entry with a count.
+
+    A timeline layer cut into many segments from one unanalyzed source clip
+    otherwise reports the same skip once per segment (87 identical rows in a
+    real two-layer session), which bloats the plan payload without adding
+    signal. First occurrence order is preserved.
+    """
+    out: List[Dict[str, Any]] = []
+    index: Dict[Tuple[Any, Any], Dict[str, Any]] = {}
+    for row in skipped:
+        key = (row.get("item"), row.get("reason"))
+        hit = index.get(key)
+        if hit is None:
+            hit = dict(row)
+            hit["count"] = 1
+            index[key] = hit
+            out.append(hit)
+        else:
+            hit["count"] += 1
+    return out
+
+
 def plan_tighten(
     project_root: str,
     *,
@@ -440,6 +466,7 @@ def plan_tighten(
                 },
             })
 
+    skipped = _dedupe_skipped(skipped)
     if not lifts:
         return {
             "success": False,
@@ -492,7 +519,9 @@ def plan_tighten(
                 audio_indices = [1]
         for seg_start, seg_end in segments:
             start_frame = int(round(seg_start * clip_fps))
-            end_frame = max(start_frame + 1, int(round(seg_end * clip_fps)) - 1)
+            # Half-open (exclusive) endFrame — duration = end - start. No -1, else
+            # every kept segment loses its last frame (see api_truth endFrame entry).
+            end_frame = max(start_frame + 1, int(round(seg_end * clip_fps)))
             keep_ranges.append({
                 "clip_id": spec["resolve_clip_id"],
                 "start_frame": start_frame,
@@ -642,7 +671,9 @@ def plan_swap(
         alt = dict(alt_clip)
         alt_fps = _clip_fps(alt)
         start_frame = int(round(float(alt_start) * alt_fps))
-        end_frame = start_frame + int(round(needed_seconds * alt_fps)) - 1
+        # Half-open (exclusive) endFrame — duration = end - start fills the slot
+        # exactly. No -1, else the replacement lands one frame short of the slot.
+        end_frame = start_frame + int(round(needed_seconds * alt_fps))
         return {
             "score": score,
             "clip_uuid": clip_uuid,