davinci-resolve-mcp 2.163.0 → 2.164.0

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 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.164.0 — E106: the changelist sees junctions
+
+`editorial.turnover_changelist` diffed clips and was blind to everything
+that happens *between* them. Measured on a faded, dissolved, retimed EDL
+pair: a 24→12-frame dissolve change reported nothing, both dropped fades
+read as "BL gone", and the zero-length CMX carrier line of a dissolve's
+outgoing side read as "B002 gone". The timing guards paired first-row-wins,
+so an identical cut with one A2 leg dropped flagged a FALSE flattened
+retime and never flagged the audio drop (`track === 'A'` missed `A2`).
+
+### Fixed
+
+- **The changelist diffs junctions.** `transition_added` /
+  `transition_dropped` / `transition_changed` entries name the outgoing and
+  incoming sources, classify fade in/out vs dissolve, and carry the span and
+  duration/type/pre-roll deltas — a dissolve reshaped from centered to
+  start-at-cut is a change even when both clips stayed put. Spans derive
+  exactly as the bridge places them (CMX start-at-cut, OTIO `in_offset`,
+  XMEML/PrProj `recStart`, AAF overlap start).
+- **Carrier lines and fade legs never read as sources.** Zero-length events
+  (CMX outgoing marker lines, the synthesized BL fade slugs) and the black
+  legs a transition references fold into the junction diff; the changelist
+  reports how many in `carriersFolded`. A cut diffed against itself is
+  silent on every axis.
+- **`timingGuards` pairs instance-to-instance.** Same track+source, closest
+  record position, consumed once — the pairing the changelist already used —
+  so a source cut twice at two speeds no longer cross-compares. Flags carry
+  `recIn`. Dropped-audio detection reads any `A`-track (`A`, `A2`, …), and a
+  lost fade or dissolve is now a timing lie (`transition_dropped`).
+
+### Added
+
+- `editorial.mjs` exports `transitionSpan(event)` and
+  `listTransitions(events)` — the junction model shared by the changelist
+  and the guards.
+
 ## What's New in v2.163.0 — E105: QC through every export format
 
 One faded, dissolved, retimed conform exported from Resolve three ways — OTIO,

package/README.md

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

package/docs/kernels/timeline-conform-interchange-kernel.md

@@ -142,7 +142,8 @@ files and the project DB.
   inside `.drp`/`.drt` as `<OfflineClip>` entries; patch them here.
 - **`editorial`** — `parse_interchange` (EDL/OTIO/XMEML natively; **AAF via pyaaf2**,
   multi-layer Avid turnovers included — honest refuse only when pyaaf2 is absent),
-  `turnover_changelist` (moved/retimed/replaced/new/gone with timing guards),
+  `turnover_changelist` (moved/retimed/trimmed/replaced/new/gone plus transitions
+  added/dropped/changed with fade in/out, with timing guards),
   `conform_manifest`, `marker_roundtrip`.
 - **`drt` / `project_db`** — timeline file authoring and DB patching.
 

package/docs/kernels/timeline-edit-kernel.md

@@ -188,8 +188,10 @@ timelines and reasons over editorial interchange with **no Resolve running**:
 
 - **`editorial`** — `parse_interchange` (EDL/OTIO/XMEML natively; **AAF via pyaaf2**,
   multi-layer Avid turnovers included — honest refuse only when pyaaf2 is absent),
-  `turnover_changelist` (moved/retimed/replaced/new/gone between two cuts, with
-  timing silent-lie guards), `conform_manifest`, `marker_roundtrip`.
+  `turnover_changelist` (moved/retimed/trimmed/replaced/new/gone between two cuts PLUS
+  the junction diff — transitions added/dropped/changed with fade in/out and span deltas,
+  CMX carriers and BL fade legs folded in — with timing silent-lie guards),
+  `conform_manifest`, `marker_roundtrip`.
 - **`drt`** — `.drt` timeline file authoring + structural diff.
 
 Use these to answer "what changed between v3 and v4" or to hand a conform an

package/install.py

@@ -37,7 +37,7 @@ from src.utils.update_check import (
 
 # ─── Version ──────────────────────────────────────────────────────────────────
 
-VERSION = "2.163.0"
+VERSION = "2.164.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.163.0",
+  "version": "2.164.0",
   "description": "NPM bootstrapper for the DaVinci Resolve MCP Server.",
   "license": "MIT",
   "author": "Samuel Gursky <samgursky@gmail.com>",

package/resolve-advanced/README.md

@@ -105,7 +105,11 @@ Each dispatches on an `action`. Highlights:
   the `otio` and `edl` targets only — this flat `drt` target has no per-clip speed field and reports
   every retime it flattens in `flattened`; for a `.drt` that AUTHORS retimes (plus dissolves,
   multi-track, audio) use `drt.assemble_from_interchange` instead),
-  `turnover_changelist` (moved/retimed/replaced/new/gone + timing silent-lie guards), `conform_manifest`,
+  `turnover_changelist` (moved/retimed/trimmed/replaced/new/gone PLUS the junction diff —
+  `transition_added`/`transition_dropped`/`transition_changed` with fade in/out, outgoing/incoming, span and
+  duration/type/pre-roll deltas; CMX carrier lines and BL fade legs fold into the junctions instead of
+  reading as gone/new sources; events pair instance-to-instance by closest record position — + timing
+  silent-lie guards incl. lost transitions and dropped audio on any A-track), `conform_manifest`,
   `marker_roundtrip`.
 - **`provenance`** — provenance / audit: `gallery_lineage`, `grade_provenance` ("why is this graded this
   way"), `cdl_export` (+ `cdl_diff`, round-trip asserted), `revision_tracking`, `episode_report`.
@@ -196,7 +200,7 @@ plausible-looking short event list. Three limits are deliberate:
   mattes) applies to what shows through from below and references no media of its own. OTIO materializes
   such layers as tracks of gaps, so its track count can exceed the number of layers with media.
 - **Only `NestedScope` layers are numbered.** Non-nested slots keep the flat `V`/`A` label, which is what
-  `editorial.mjs`'s `track === 'A'` audio-follows-video heuristic reads.
+  `editorial.mjs`'s `/^A\d*$/` audio-follows-video heuristic reads (`A`, `A2`, … all count as audio).
 
 ## Provenance & license
 Vendored libraries are clean offline format-interop and deterministic compute code: no secrets, no

package/resolve-advanced/server/editorial.mjs

@@ -476,38 +476,139 @@ export function parseInterchange(format, content, opts = {}) {
 
 // ── turnover_changelist ────────────────────────────────────────────────
 const sig = (e) => `${e.track}:${e.source}`;
+const isBlackSource = (s) => /^(bl|black|solid color)$/i.test(String(s || '').trim());
+const isAudioTrack = (t) => /^A\d*$/i.test(String(t || ''));
+// A zero-length event is a CARRIER, never a cut: the outgoing marker line of
+// a CMX dissolve pair, or the zero-length BL slug every parser synthesizes at
+// a fade (E91/E92/E93). It has no picture of its own to be moved/gone/new.
+const isCarrier = (e) => e.recIn != null && e.recOut != null && e.recIn === e.recOut;
 
 /**
- * Diff two normalized event lists → per-event {kind: moved|retimed|replaced|new|gone|unchanged}.
+ * The record SPAN a transition event occupies, derived exactly the way the
+ * bridge places it (author-interchange): alignment 'start' → the span begins
+ * at the incoming's recIn (CMX start-at-cut / AAF overlap start); OTIO
+ * inOffset → that many frames before the cut; XMEML/PrProj recStart → the
+ * explicit span start; nothing declared → centered. `junction` is the
+ * incoming event's recIn — the same frame verify_roundtrip's fade windows
+ * key on.
+ * @param {Object} e normalized event carrying `transition`
+ */
+export function transitionSpan(e) {
+  const t = e.transition;
+  if (!t || e.recIn == null) return null;
+  const d = Math.max(0, Number(t.duration) || 0);
+  let pre;
+  if (t.alignment === 'start') pre = 0;
+  else if (t.inOffset != null) pre = Math.max(0, Math.min(d, Number(t.inOffset) || 0));
+  else if (t.recStart != null) pre = Math.max(0, Math.min(d, e.recIn - Number(t.recStart)));
+  else pre = Math.floor(d / 2);
+  const start = e.recIn - pre;
+  return { start, end: start + d, junction: e.recIn, pre, duration: d };
+}
+
+/**
+ * Every junction in an event list as a transition record: span, type, the
+ * OUTGOING event (the same-track neighbour whose extent touches the span
+ * start — a CMX carrier line, an abutting clip, or the overlapping AAF
+ * predecessor) and the INCOMING (the carrier of the `transition` field), with
+ * black on either side classified as a fade. Pure over events.
+ * @param {Array} events
+ * @returns {Array<{track,type,duration,start,end,junction,pre,outgoing,incoming,fade,incomingEvent,outgoingEvent}>}
+ */
+export function listTransitions(events) {
+  const out = [];
+  for (const e of events) {
+    if (!e.transition || !(Number(e.transition.duration) > 0)) continue;
+    const span = transitionSpan(e);
+    if (!span) continue;
+    const cands = events.filter((o) => o !== e && o.track === e.track && o.recIn != null && o.recOut != null
+      && o.recIn <= span.start && o.recOut >= span.start);
+    // The latest-ending toucher is the outgoing: a carrier line sits exactly
+    // at the span start, an abutting clip ends there, an AAF predecessor
+    // overlaps past it. Prefer a picture over black only when both touch.
+    cands.sort((a, b) => (b.recOut - a.recOut) || ((events.indexOf(b)) - events.indexOf(a)));
+    let outgoingEvent = cands[0] || null;
+    if (!outgoingEvent) {
+      // Nothing touches the span start (a pre-rolled fade-in at track start
+      // whose span begins before frame 0, or a gap-adjacent junction): the
+      // outgoing is whatever last ENDED at or before the junction — the
+      // zero-length BL slug the parsers synthesize sits exactly there.
+      const before = events.filter((o) => o !== e && o.track === e.track && o.recOut != null && o.recOut <= span.junction);
+      before.sort((a, b) => (b.recOut - a.recOut) || (events.indexOf(b) - events.indexOf(a)));
+      outgoingEvent = before[0] || null;
+    }
+    const outgoing = outgoingEvent ? outgoingEvent.source : null;
+    const incoming = e.source;
+    const fade = isBlackSource(outgoing) ? 'in' : isBlackSource(incoming) ? 'out' : null;
+    out.push({
+      track: e.track, type: e.transition.type || 'dissolve', duration: span.duration,
+      start: span.start, end: span.end, junction: span.junction, pre: span.pre,
+      outgoing, incoming, fade, incomingEvent: e, outgoingEvent,
+    });
+  }
+  return out;
+}
+
+/**
+ * Pair old and new PICTURE/AUDIO events once each: same track+source, closest
+ * record position wins, consumed on match (a source used twice at two speeds
+ * pairs each instance with its own — never first-row-wins). Carriers and the
+ * black legs a transition references never enter the pairing: they are the
+ * junction's business (listTransitions), not sources.
+ */
+function pairEvents(oldEvents, newEvents, recTol = 1) {
+  const cutsOf = (events) => {
+    const trs = listTransitions(events);
+    const fadeBlack = new Set();
+    for (const t of trs) {
+      if (t.outgoingEvent && isBlackSource(t.outgoingEvent.source)) fadeBlack.add(t.outgoingEvent);
+      if (isBlackSource(t.incomingEvent.source)) fadeBlack.add(t.incomingEvent);
+    }
+    const cuts = [], carriers = [];
+    for (const e of events) {
+      if (e.track === 'MARKER') continue;
+      if (isCarrier(e) || fadeBlack.has(e)) carriers.push(e);
+      else cuts.push(e);
+    }
+    return { cuts, carriers, transitions: trs };
+  };
+  const o = cutsOf(oldEvents), n = cutsOf(newEvents);
+  const pool = o.cuts.map((e) => ({ e, used: false }));
+  const pairs = [], unmatchedNew = [];
+  for (const ne of n.cuts) {
+    const cands = pool.filter((p) => !p.used && sig(p.e) === sig(ne));
+    if (!cands.length) { unmatchedNew.push(ne); continue; }
+    cands.sort((a, b) => Math.abs((a.e.recIn ?? 0) - (ne.recIn ?? 0)) - Math.abs((b.e.recIn ?? 0) - (ne.recIn ?? 0)));
+    cands[0].used = true;
+    pairs.push({ oe: cands[0].e, ne });
+  }
+  const unmatchedOld = pool.filter((p) => !p.used).map((p) => p.e);
+  return { pairs, unmatchedOld, unmatchedNew, old: o, new: n, recTol };
+}
+
+/**
+ * Diff two normalized event lists → per-event {kind: moved|retimed|trimmed|replaced|new|gone}
+ * PLUS per-junction {kind: transition_added|transition_dropped|transition_changed}
+ * (fade 'in'/'out' or null for a dissolve). Zero-length carrier lines and the
+ * black legs that carry fades fold into the junction diff instead of reading
+ * as gone/new sources; a dissolve whose duration, type or span shape changed
+ * is a change even when both clips stayed put.
  * @param {Array} oldEvents
  * @param {Array} newEvents
  * @param {{recTolerance?:number}} [opts]
  */
 export function diffChangelist(oldEvents, newEvents, opts = {}) {
   const recTol = opts.recTolerance ?? 1;
-  const oldPool = oldEvents.map((e) => ({ e, used: false }));
+  const P = pairEvents(oldEvents, newEvents, recTol);
   const changes = [];
 
-  for (const ne of newEvents) {
-    // Prefer a same-source match; among those, the closest record position.
-    const candidates = oldPool.filter((o) => !o.used && sig(o.e) === sig(ne));
-    let match = null;
-    if (candidates.length) {
-      candidates.sort((a, b) => Math.abs((a.e.recIn ?? 0) - (ne.recIn ?? 0)) - Math.abs((b.e.recIn ?? 0) - (ne.recIn ?? 0)));
-      match = candidates[0];
-    }
-    if (!match) {
-      changes.push({ kind: 'new', source: ne.source, track: ne.track, newRecIn: ne.recIn });
-      continue;
-    }
-    match.used = true;
-    const oe = match.e;
+  for (const { oe, ne } of P.pairs) {
     const deltas = {};
     let kind = 'unchanged';
-    if (Math.abs((oe.speed ?? 100) - (ne.speed ?? 100)) > 0.01 || oe.reverse !== ne.reverse) {
+    if (Math.abs((oe.speed ?? 100) - (ne.speed ?? 100)) > 0.01 || Boolean(oe.reverse) !== Boolean(ne.reverse)) {
       kind = 'retimed';
       deltas.speed = { old: oe.speed, new: ne.speed };
-      if (oe.reverse !== ne.reverse) deltas.reverse = { old: oe.reverse, new: ne.reverse };
+      if (Boolean(oe.reverse) !== Boolean(ne.reverse)) deltas.reverse = { old: oe.reverse, new: ne.reverse };
     } else if (Math.abs((oe.recIn ?? 0) - (ne.recIn ?? 0)) > recTol) {
       kind = 'moved';
       deltas.recIn = { old: oe.recIn, new: ne.recIn };
@@ -517,51 +618,97 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
     }
     if (kind !== 'unchanged') changes.push({ kind, source: ne.source, track: ne.track, oldRecIn: oe.recIn, newRecIn: ne.recIn, deltas });
   }
+  for (const ne of P.unmatchedNew) changes.push({ kind: 'new', source: ne.source, track: ne.track, newRecIn: ne.recIn });
   // Unconsumed old events → gone (unless a 'new' at the same rec position → replaced).
-  for (const o of oldPool.filter((x) => !x.used)) {
-    const replacement = changes.find((c) => c.kind === 'new' && c.track === o.e.track && Math.abs((c.newRecIn ?? 0) - (o.e.recIn ?? 0)) <= recTol);
+  for (const oe of P.unmatchedOld) {
+    const replacement = changes.find((c) => c.kind === 'new' && c.track === oe.track && Math.abs((c.newRecIn ?? 0) - (oe.recIn ?? 0)) <= recTol);
     if (replacement) {
       replacement.kind = 'replaced';
-      replacement.oldSource = o.e.source;
-      replacement.oldRecIn = o.e.recIn;
+      replacement.oldSource = oe.source;
+      replacement.oldRecIn = oe.recIn;
     } else {
-      changes.push({ kind: 'gone', source: o.e.source, track: o.e.track, oldRecIn: o.e.recIn });
+      changes.push({ kind: 'gone', source: oe.source, track: oe.track, oldRecIn: oe.recIn });
+    }
+  }
+
+  // Junction diff: a transition is identified by what it joins (track,
+  // outgoing, incoming, fade side) and pairs with the closest junction; only
+  // its SHAPE (duration / type / pre-roll) makes a change — a junction that
+  // travelled with its clips is the clips' move, already reported.
+  const tKey = (t) => `${t.track}|${t.outgoing ?? ''}|${t.incoming}|${t.fade ?? 'x'}`;
+  const tPool = P.old.transitions.map((t) => ({ t, used: false }));
+  const tDesc = (t) => ({ track: t.track, outgoing: t.outgoing, incoming: t.incoming, fade: t.fade, type: t.type, duration: t.duration });
+  for (const nt of P.new.transitions) {
+    const cands = tPool.filter((p) => !p.used && tKey(p.t) === tKey(nt));
+    if (!cands.length) {
+      changes.push({ kind: 'transition_added', ...tDesc(nt), newRecIn: nt.junction, newSpan: [nt.start, nt.end] });
+      continue;
+    }
+    cands.sort((a, b) => Math.abs(a.t.junction - nt.junction) - Math.abs(b.t.junction - nt.junction));
+    cands[0].used = true;
+    const ot = cands[0].t;
+    const deltas = {};
+    if (ot.duration !== nt.duration) deltas.duration = { old: ot.duration, new: nt.duration };
+    if (String(ot.type) !== String(nt.type)) deltas.type = { old: ot.type, new: nt.type };
+    if (ot.pre !== nt.pre) deltas.pre = { old: ot.pre, new: nt.pre };
+    if (Object.keys(deltas).length) {
+      changes.push({
+        kind: 'transition_changed', ...tDesc(nt), oldRecIn: ot.junction, newRecIn: nt.junction,
+        oldSpan: [ot.start, ot.end], newSpan: [nt.start, nt.end], deltas,
+      });
     }
   }
+  for (const p of tPool.filter((x) => !x.used)) {
+    changes.push({ kind: 'transition_dropped', ...tDesc(p.t), oldRecIn: p.t.junction, oldSpan: [p.t.start, p.t.end] });
+  }
+
   const counts = {};
   for (const c of changes) counts[c.kind] = (counts[c.kind] || 0) + 1;
   changes.sort((a, b) => (a.newRecIn ?? a.oldRecIn ?? 0) - (b.newRecIn ?? b.oldRecIn ?? 0));
-  return { changes, counts, changedCount: changes.length, gate: 'review' };
+  return {
+    changes, counts, changedCount: changes.length,
+    transitions: { old: P.old.transitions.length, new: P.new.transitions.length },
+    carriersFolded: { old: P.old.carriers.length, new: P.new.carriers.length },
+    gate: 'review',
+  };
 }
 
 // ── TIMING silent-lie guards ───────────────────────────────────────────
 /**
  * Detect timing lies between an old (locked-cut) and new (conformed) event list.
+ * Pairs events the same way the changelist does (closest record position,
+ * consumed once) so a source cut twice at two speeds is compared instance to
+ * instance — never the second old against the first new.
  * @returns {{flags:Array<{kind, source, detail}>}}
  */
 export function timingGuards(oldEvents, newEvents) {
   const flags = [];
-  const newBySig = new Map();
-  for (const e of newEvents) {
-    if (!newBySig.has(sig(e))) newBySig.set(sig(e), []);
-    newBySig.get(sig(e)).push(e);
+  const P = pairEvents(oldEvents, newEvents);
+  for (const oe of P.unmatchedOld) {
+    // A dropped audio event where its video sibling survives → dropped J/L-cut audio.
+    if (isAudioTrack(oe.track) && P.new.cuts.some((x) => !isAudioTrack(x.track) && x.track !== 'MARKER' && x.source === oe.source))
+      flags.push({ kind: 'dropped_split_audio', source: oe.source, track: oe.track, detail: `audio event (${oe.track}) gone but video sibling present (J/L-cut lost)` });
   }
-  for (const oe of oldEvents) {
-    const matches = newBySig.get(sig(oe)) || [];
-    const ne = matches[0];
-    if (!ne) {
-      // A dropped audio event where its video sibling survives → dropped J/L-cut audio.
-      if (oe.track === 'A' && newEvents.some((x) => x.track !== 'A' && x.source === oe.source))
-        flags.push({ kind: 'dropped_split_audio', source: oe.source, detail: 'audio event gone but video sibling present (J/L-cut lost)' });
-      continue;
-    }
+  for (const { oe, ne } of P.pairs) {
     // Flattened retime: a speed ramp/change flattened to 100%.
     if ((oe.speed ?? 100) !== 100 && (ne.speed ?? 100) === 100)
-      flags.push({ kind: 'flattened_retime', source: oe.source, detail: `speed ${oe.speed}% → 100% (retime lost)` });
+      flags.push({ kind: 'flattened_retime', source: oe.source, recIn: oe.recIn, detail: `speed ${oe.speed}% → 100% (retime lost)` });
     // Reverse dropped.
-    if (oe.reverse && !ne.reverse) flags.push({ kind: 'reverse_dropped', source: oe.source, detail: 'reversed clip conformed forward' });
+    if (oe.reverse && !ne.reverse) flags.push({ kind: 'reverse_dropped', source: oe.source, recIn: oe.recIn, detail: 'reversed clip conformed forward' });
     // Framerate/pulldown slip.
-    if (oe.fps && ne.fps && oe.fps !== ne.fps) flags.push({ kind: 'framerate_slip', source: oe.source, detail: `fps ${oe.fps} → ${ne.fps}` });
+    if (oe.fps && ne.fps && oe.fps !== ne.fps) flags.push({ kind: 'framerate_slip', source: oe.source, recIn: oe.recIn, detail: `fps ${oe.fps} → ${ne.fps}` });
+  }
+  // A fade or dissolve the conform lost is a timing lie too: the picture
+  // edges stay put while the blend at the junction silently hard-cuts.
+  const tKey = (t) => `${t.track}|${t.outgoing ?? ''}|${t.incoming}|${t.fade ?? 'x'}`;
+  const newKeys = P.new.transitions.map(tKey);
+  for (const ot of P.old.transitions) {
+    const i = newKeys.indexOf(tKey(ot));
+    if (i >= 0) { newKeys.splice(i, 1); continue; }
+    flags.push({
+      kind: 'transition_dropped', source: ot.incoming, track: ot.track, recIn: ot.junction,
+      detail: ot.fade ? `fade-${ot.fade} (${ot.duration}f) at ${ot.junction} lost` : `${ot.outgoing}→${ot.incoming} dissolve (${ot.duration}f) at ${ot.junction} lost`,
+    });
   }
   return { flags, flagged: flags.length > 0 };
 }

package/resolve-advanced/server/tools/editorial.mjs

@@ -86,7 +86,7 @@ const markerSchema = z.object({
 export const editorialTool = {
   name: 'editorial',
   description:
-    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively — incl. Resolve-written FCP7 -1 junction edges + Solid Color generators, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 + PRPROJ via gunzip+XML → normalized events incl. span-explicit transitions, BL fade legs, and freezes as zero-speed events (OTIO FreezeFrame, XMEML timeremap 0, PrProj in==out, AAF 0% motion effects); for AAF/PRPROJ pass the file PATH as content; AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source; the EDL target writes CMX transition pairs incl. BL fades — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → moved/retimed/replaced/new/gone + timing flags), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base; BL-aware — black legs need no source, fades no black-side handles, and a fade-out tail requirement lands on the picture source), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets + marker compare w/ markersNotInExport honesty flag; FADE-AWARE: BL/Solid-Color legs merge out as blackSegments and fade-window boundary reshapes are excused into fadeReshapedBoundaries instead of failing; RETIME-AWARE: speed/reverse compare pairwise — EXPORT_OTIO carries an authored Sm2TimeMap back as LinearTimeWarp (measured), so a flattened/lost retime fails as drift geometry alone cannot catch; AUDIO-AWARE: declared audio events compare (a video-only export such as EXPORT_EDL flags audioNotInExport instead of failing) (channel legs deduped, mismatches tagged trackType audio) while the mirrored-A1 export of a video-only turnover stays informational; the conform QC loop-closer). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
+    'Editorial integrity (Cluster E) — turnover interchange → normalized events → changelist + conform manifest with TIMING silent-lie guards (flattened retime / dropped J/L-cut audio / framerate-pulldown slip / reverse dropped / transition-handle starvation → flag, skip-not-fake). Report-only (gate: review). Actions: parse_interchange (EDL/OTIO/XMEML natively — incl. Resolve-written FCP7 -1 junction edges + Solid Color generators, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 + PRPROJ via gunzip+XML → normalized events incl. span-explicit transitions, BL fade legs, and freezes as zero-speed events (OTIO FreezeFrame, XMEML timeremap 0, PrProj in==out, AAF 0% motion effects); for AAF/PRPROJ pass the file PATH as content; AAF also returns per-sequence startTimecode/startFrame — build the timeline at THAT start, not the Resolve 01:00:00:00 default — and per-clip `geometry` for Avid transform effects), list_sequences (ONE offline picker entry point across xml/edl/otio/drt/drp/aaf/prproj → [{id,name,eventCount}], plus startTimecode/startFrame for AAF), convert_to_interchange (author OTIO/EDL/DRT Resolve CAN import from events or a parsed source; the EDL target writes CMX transition pairs incl. BL fades — the .prproj→Resolve conform bridge, no Premiere needed; editorial timing/transitions survive and per-clip effects/color do not. SPEED/REVERSE survive on the otio (LinearTimeWarp) and edl (M2) targets ONLY — this FLAT drt target flattens every retime to 100% forward and returns `flattened`/`flattenedCount` naming each event that lost one (`flattened` is always present on `drt`, empty when there were none); for a .drt that AUTHORS retimes/dissolves/multi-track/audio, use drt.assemble_from_interchange), turnover_changelist (diff old vs new → moved/retimed/trimmed/replaced/new/gone PLUS the junction diff: transition_added/transition_dropped/transition_changed with fade in/out or dissolve, outgoing/incoming, span and duration/type/pre-roll deltas — zero-length CMX carrier lines and the BL legs that carry fades fold into the junction diff instead of reading as gone/new sources; events pair by closest record position, consumed once, so a source cut twice at two speeds compares instance to instance; + timing flags incl. transition_dropped and dropped_split_audio on any A-track), conform_manifest (per-event assert: source resolved/handles/retime/reverse/TC-base; BL-aware — black legs need no source, fades no black-side handles, and a fade-out tail requirement lands on the picture source), marker_roundtrip (markers with provenance tags), verify_roundtrip (input events vs re-export events -> pass/mismatches + fitted per-source TC offsets + marker compare w/ markersNotInExport honesty flag; FADE-AWARE: BL/Solid-Color legs merge out as blackSegments and fade-window boundary reshapes are excused into fadeReshapedBoundaries instead of failing; RETIME-AWARE: speed/reverse compare pairwise — EXPORT_OTIO carries an authored Sm2TimeMap back as LinearTimeWarp (measured), so a flattened/lost retime fails as drift geometry alone cannot catch; AUDIO-AWARE: declared audio events compare (a video-only export such as EXPORT_EDL flags audioNotInExport instead of failing) (channel legs deduped, mismatches tagged trackType audio) while the mirrored-A1 export of a video-only turnover stays informational; the conform QC loop-closer). Offline (AAF needs pyaaf2; live AAF/DRP import is on the Python davinci-resolve MCP).',
   async handler({ action, args }) {
     if (action === 'parse_interchange') {
       const p = parseSchema.parse(args);

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.163.0"
+VERSION = "2.164.0"
 logger = logging.getLogger("davinci-resolve-mcp")
 logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION}")
 logger.info(f"Detected platform: {get_platform()}")

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 353-tool granular server instead
 """
 
-VERSION = "2.163.0"
+VERSION = "2.164.0"
 
 import base64
 import os