davinci-resolve-mcp 2.192.0 → 2.194.0

package/CHANGELOG.md

@@ -2,6 +2,70 @@
 
 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.194.0 — E142: a cut re-aligned inside a dissolve is the same picture
+
+### Added
+
+- **A cut re-aligned inside an unchanged dissolve is the same picture.**
+  Premiere keeps a fractional dissolve alignment (its cut sat 12 frames into a
+  46-frame span); Resolve's conform re-centres it (23). The dissolve covers
+  the same record frames from the same media either way, but the changelist
+  read each one as a `moved` incoming plus a `trimmed` outgoing. When a
+  transition's span is unchanged and the cut inside it moved with the
+  incoming's source-in and the outgoing's source-out sliding by the same
+  delta (scaled by the clip's speed for a retimed clip, read through a TC
+  rebase), the pair folds into ONE `junction_realigned` — a consequence, not
+  an edit — both sides count as retained, and the junction diff no longer
+  reports the pre-roll change as a second fact. A dissolve whose span moved,
+  or a cut whose source did not slide with it, stays a real move.
+- **Two labels of one transition family are a relabel.** `Cross Dissolve
+  (Legacy)` in Premiere and `Cross Dissolve` in Resolve are the same effect;
+  they now land in `transitionRelabels` instead of `transition_changed`. A
+  different family (a push, a wipe) is still a type change.
+- **Shape `equivalent`.** A diff whose only changes are consequences (junctions
+  re-aligned, labels) now says so, with a note, instead of `edit`.
+
+On the real reel (Premiere REEL_02 pix-lock vs the Resolve conform): 206 of
+228 cuts retained (189 before), 9 junctions re-aligned, 10 relabels, one real
+move (a dissolve whose span moved), one real transition change, 19 trims on
+the eye-matched files, the second mix track, the reversed tail leader and
+frozen black — symmetric in both directions.
+
+## What's New in v2.193.0 — E141: relink-aware changelist
+
+### Added
+
+- **`turnover_changelist` is relink-aware.** A real offline→online turnover
+  (the Premiere REEL_02 pix-lock against the Resolve conform of the same reel)
+  paired 15 of 228 cuts: the offline media was named `… 4K-2K … .mov`
+  (proxies) where the online cut used `… 4K … .mov` (masters) and `.mp4`
+  became `.mov`, so 203 identical cuts read as `replaced`. Now `sourceAliases`
+  (`{from,to}` exact or `{pattern,replace}` regex) rename old sources before
+  pairing, and a systematic rename is INFERRED from unpaired cuts that share
+  a record window — adopted only when one-to-one both ways and either
+  recurring or clearly the same name (LCS similarity ≥ 0.6), so a different
+  shot dropped into the same window stays `replaced`. The result reports
+  every alias with its cut count, similarity and whether it was inferred.
+- **A per-source timecode rebase is not N trims.** Masters carry a different
+  timecode base than the proxies: the same cuts read as `trimmed` by one
+  constant shift. When one shift is a source's dominant story (≥2 cuts and
+  more than half of its differing cuts) the compare reads old through it and
+  reports it in `sourceTcOffsets`; a cut that still differs is a real trim on
+  top of the rebase, with the pre-rebase window kept in its deltas. A source
+  whose cuts each shift by a different amount (an eye-matched re-conform onto
+  other media) stays trims — measured: two of seven cuts sharing a shift is a
+  coincidence, not a base.
+- **Premiere synthetic items name themselves.** A Universal Counting Leader
+  or Black Video has no file: its `Media` writes a bare numeric id as the
+  path and the human name in `<Title>`. They now read by title and carry
+  `generatorName`, so they pair with the online cut's generators by name
+  instead of reporting a numeric id replaced.
+
+On the real reel: 189 of 228 cuts retained (was 15), 16 aliases inferred, one
+source rebased by 47745 frames, symmetric in both directions; what remains is
+the conform's own story — 27 trims, 10 junctions moved inside dissolves, the
+online reel's second mix track, its reversed tail leader and frozen black.
+
 ## What's New in v2.192.0 — E140: a .drt retime decodes to its speed
 
 ### Added

package/README.md

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

package/install.py

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

package/resolve-advanced/server/editorial.mjs

@@ -837,7 +837,15 @@ function pairEvents(oldEvents, newEvents, recTol = 1) {
 
 /**
  * Diff two normalized event lists → a SHAPE verdict (identical|subset|superset|edit, E138)
- * plus per-event {kind: moved|retimed|trimmed|replaced|new|gone}
+ * plus per-event {kind: moved|retimed|trimmed|replaced|new|gone}; RELINK-aware (E141):
+ * opts.sourceAliases ({from,to} | {pattern,replace}) rename old sources first, a
+ * systematic rename is inferred from same-window unpaired cuts (opts.inferAliases
+ * !== false) and reported in sourceAliases, and a constant per-source source-window
+ * shift witnessed on ≥2 cuts is a TC rebase (sourceTcOffsets), not trims. A cut moved
+ * INSIDE an unchanged dissolve span with both source windows sliding by the same delta
+ * is one junction_realigned (E142) — a consequence — and two labels of one transition
+ * family are a relabel (transitionRelabels), so a picture-identical conform reads
+ * shape 'equivalent'.
  * 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
@@ -847,7 +855,94 @@ function pairEvents(oldEvents, newEvents, recTol = 1) {
  * @param {Array} newEvents
  * @param {{recTolerance?:number}} [opts]
  */
+// ── RELINK awareness (E141) ────────────────────────────────────────────
+// A real offline→online turnover (Premiere REEL_02 → the Resolve conform of
+// the same reel) paired 15 of 228 cuts: the offline media was named
+// "… 4K-2K … .mov" (proxies) where the online cut used "… 4K … .mov"
+// (masters) and ".mp4" became ".mov", so 203 identical cuts read as
+// `replaced`; and the masters carry a different timecode base, so the same
+// cuts read as `trimmed` by a constant per-source shift. Neither is an edit.
+const normalizeAliases = (list) => (Array.isArray(list) ? list : []).map((a) => {
+  if (!a || typeof a !== 'object') throw new Error('sourceAliases: each entry is {from,to} or {pattern,replace}');
+  if (a.pattern != null) return { pattern: String(a.pattern), replace: String(a.replace ?? ''), re: new RegExp(a.pattern, a.flags || 'g'), inferred: false };
+  if (a.from != null && a.to != null) return { from: String(a.from), to: String(a.to), inferred: false };
+  throw new Error('sourceAliases: each entry is {from,to} or {pattern,replace}');
+});
+const aliasSource = (src, aliases) => {
+  let s = String(src ?? '');
+  for (const a of aliases) {
+    if (a.re) s = s.replace(a.re, a.replace);
+    else if (s === a.from) s = a.to;
+  }
+  return s;
+};
+const applyAliases = (events, aliases) => (aliases.length
+  ? events.map((e) => { const s = aliasSource(e.source, aliases); return s === String(e.source ?? '') ? e : { ...e, source: s, aliasedFrom: e.source }; })
+  : events);
+// Longest-common-subsequence ratio, case-insensitive: 1 = identical names.
+function nameSimilarity(a, b) {
+  const x = String(a || '').toLowerCase(), y = String(b || '').toLowerCase();
+  if (!x.length || !y.length) return 0;
+  let prev = new Array(y.length + 1).fill(0);
+  for (let i = 1; i <= x.length; i++) {
+    const cur = new Array(y.length + 1).fill(0);
+    for (let j = 1; j <= y.length; j++) cur[j] = x[i - 1] === y[j - 1] ? prev[j - 1] + 1 : Math.max(prev[j], cur[j - 1]);
+    prev = cur;
+  }
+  return (2 * prev[y.length]) / (x.length + y.length);
+}
+/**
+ * Infer a systematic RENAME from the cuts a first pass could not pair: an
+ * unpaired old cut and an unpaired new cut on the same track with the same
+ * record window are the same cut under two names. An alias is adopted when
+ * the mapping is one-to-one both ways and either recurs (≥2 cuts) or the two
+ * names are clearly the same name (LCS similarity ≥ 0.6) — a genuinely
+ * different shot dropped into the same window is neither.
+ */
+function inferSourceAliases(P, recTol) {
+  const cands = new Map(); // from -> Map(to -> count)
+  const usedNew = new Set();
+  for (const oe of P.unmatchedOld) {
+    const hit = P.unmatchedNew.find((ne) => !usedNew.has(ne) && ne.track === oe.track
+      && Math.abs((ne.recIn ?? 0) - (oe.recIn ?? 0)) <= recTol && Math.abs((ne.recOut ?? 0) - (oe.recOut ?? 0)) <= recTol);
+    if (!hit) continue;
+    usedNew.add(hit);
+    const from = String(oe.source ?? ''), to = String(hit.source ?? '');
+    if (from === to) continue;
+    if (!cands.has(from)) cands.set(from, new Map());
+    cands.get(from).set(to, (cands.get(from).get(to) || 0) + 1);
+  }
+  const claimed = new Map(); // to -> from
+  const out = [];
+  for (const [from, tos] of cands) {
+    if (tos.size !== 1) continue;
+    const [to, count] = [...tos][0];
+    if (claimed.has(to) && claimed.get(to) !== from) continue;
+    const similarity = Math.round(nameSimilarity(from, to) * 1000) / 1000;
+    if (count >= 2 || similarity >= 0.6) { claimed.set(to, from); out.push({ from, to, cuts: count, similarity, inferred: true }); }
+  }
+  // A 'to' claimed by two different 'from's is ambiguous — drop both.
+  const toCounts = new Map(); for (const a of out) toCounts.set(a.to, (toCounts.get(a.to) || 0) + 1);
+  return out.filter((a) => toCounts.get(a.to) === 1);
+}
+
 export function diffChangelist(oldEvents, newEvents, opts = {}) {
+  const explicit = normalizeAliases(opts.sourceAliases);
+  let aliases = explicit;
+  let result = diffChangelistOnce(applyAliases(oldEvents, aliases), newEvents, opts);
+  if (opts.inferAliases !== false) {
+    const inferred = inferSourceAliases(result.__P, opts.recTolerance ?? 1);
+    if (inferred.length) {
+      aliases = [...explicit, ...inferred];
+      result = diffChangelistOnce(applyAliases(oldEvents, aliases), newEvents, opts);
+    }
+  }
+  const { __P, ...out } = result;
+  out.sourceAliases = aliases.map((a) => (a.re ? { pattern: a.pattern, replace: a.replace, inferred: false } : { from: a.from, to: a.to, inferred: Boolean(a.inferred), ...(a.cuts != null ? { cuts: a.cuts, similarity: a.similarity } : {}) }));
+  return out;
+}
+
+function diffChangelistOnce(oldEvents, newEvents, opts = {}) {
   const recTol = opts.recTolerance ?? 1;
   const changes = [];
   // COMPOUND FORMS (E124): a compound is one collapsed item in an XML cut
@@ -873,10 +968,41 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
   }
   const P = pairEvents(oldEvents.filter((e) => !skipOld.has(e)), newEvents.filter((e) => !skipNew.has(e)), recTol);
 
+  // TC REBASE (E141): when every differing cut of a source shifts its source
+  // window by the SAME amount in and out, the media was relinked to a copy
+  // with a different timecode base (offline proxies at 0, masters at their
+  // camera TC) — not N trims. A shift witnessed on ≥2 cuts of a source is
+  // that source's offset; the compare below reads old through it, and a cut
+  // that still differs is a real trim on top of the rebase.
+  const shiftTally = new Map(), differing = new Map();
+  for (const { oe, ne } of P.pairs) {
+    if ([oe.srcIn, oe.srcOut, ne.srcIn, ne.srcOut].some((v) => v == null)) continue;
+    const dIn = ne.srcIn - oe.srcIn, dOut = ne.srcOut - oe.srcOut;
+    if (dIn === 0 && dOut === 0) continue;
+    const key = String(ne.source ?? '');
+    differing.set(key, (differing.get(key) || 0) + 1);
+    if (dIn === 0 || dIn !== dOut) continue;
+    if (!shiftTally.has(key)) shiftTally.set(key, new Map());
+    shiftTally.get(key).set(dIn, (shiftTally.get(key).get(dIn) || 0) + 1);
+  }
+  // A rebase is the source's DOMINANT story: the same shift on ≥2 cuts AND
+  // on more than half of the cuts whose windows differ at all. A source whose
+  // cuts each shift by a different amount (an eye-matched re-conform onto
+  // other media — measured: two of seven cuts happened to share a shift) is
+  // trims, not a base change.
+  const tcOffsets = new Map();
+  for (const [source, tally] of shiftTally) {
+    const [offset, cuts] = [...tally].sort((a, b) => b[1] - a[1])[0];
+    if (cuts >= 2 && cuts > (differing.get(source) || 0) / 2) tcOffsets.set(source, { source, offset, cuts, rebased: 0 });
+  }
+
   const retained = [];
   for (const { oe, ne } of P.pairs) {
     const deltas = {};
     let kind = 'unchanged';
+    const tc = tcOffsets.get(String(ne.source ?? ''));
+    const off = tc ? tc.offset : 0;
+    const oIn = oe.srcIn == null ? null : oe.srcIn + off, oOut = oe.srcOut == null ? null : oe.srcOut + off;
     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 };
@@ -884,9 +1010,11 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
     } else if (Math.abs((oe.recIn ?? 0) - (ne.recIn ?? 0)) > recTol) {
       kind = 'moved';
       deltas.recIn = { old: oe.recIn, new: ne.recIn };
-    } else if ((oe.srcIn ?? null) !== (ne.srcIn ?? null) || (oe.srcOut ?? null) !== (ne.srcOut ?? null)) {
+    } else if ((oIn ?? null) !== (ne.srcIn ?? null) || (oOut ?? null) !== (ne.srcOut ?? null)) {
       kind = 'trimmed';
-      deltas.src = { old: [oe.srcIn, oe.srcOut], new: [ne.srcIn, ne.srcOut] };
+      deltas.src = { old: [oIn, oOut], new: [ne.srcIn, ne.srcOut], ...(off ? { tcOffset: off, oldBeforeRebase: [oe.srcIn, oe.srcOut] } : {}) };
+    } else if (off && ((oe.srcIn ?? null) !== (ne.srcIn ?? null))) {
+      tc.rebased += 1;
     }
     if (kind !== 'unchanged') changes.push({ kind, source: ne.source, track: ne.track, oldRecIn: oe.recIn, newRecIn: ne.recIn, deltas });
     else retained.push(ne);
@@ -904,10 +1032,60 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
     }
   }
 
+  // JUNCTION REALIGN (E142): a cut that moved INSIDE an unchanged dissolve
+  // span, with the incoming's source in and the outgoing's source out
+  // sliding by the same amount, shows the identical picture — the dissolve
+  // covers the same record frames from the same media either way. Premiere
+  // keeps a fractional alignment (its cut sat 12 frames into a 46-frame
+  // span); Resolve's conform re-centred it (23). Measured on a real reel: 9
+  // of 10 residual 'moved' cuts were this, the tenth a real edit (its span
+  // moved too). Fold each into one junction_realigned — a consequence, not
+  // an edit — and let the junction diff read the pre-roll change as the
+  // same fact.
+  const realigned = new Set();
+  const pairAtIn = (recIn, track) => P.pairs.find((pr) => pr.oe.track === track && pr.oe.recIn === recIn);
+  const pairAtOut = (recOut, track) => P.pairs.find((pr) => pr.oe.track === track && pr.oe.recOut === recOut);
+  for (const ot of P.old.transitions) {
+    const nt = P.new.transitions.find((t) => t.track === ot.track && Math.abs(t.start - ot.start) <= recTol && Math.abs(t.end - ot.end) <= recTol);
+    if (!nt) continue;
+    const delta = nt.junction - ot.junction;
+    if (!delta) continue;
+    const inc = pairAtIn(ot.junction, ot.track), out = pairAtOut(ot.junction, ot.track);
+    if (!inc || inc.ne.recIn !== nt.junction) continue;
+    // The source slides by the cut delta at the clip's speed (a retimed
+    // incoming at 80% slides 6 source frames for an 8-frame cut move —
+    // measured on the reel's V3 fade-in); a TC-rebased outgoing is read
+    // through its offset.
+    const slide = (ev) => Math.round(delta * ((ev.speed ?? 100) / 100));
+    const near = (a, b) => a != null && b != null && Math.abs(a - b) <= 1;
+    const offOf = (ev) => (tcOffsets.get(String(ev.source ?? '')) ? tcOffsets.get(String(ev.source ?? '')).offset : 0);
+    const incOk = near(inc.ne.srcIn - (inc.oe.srcIn + offOf(inc.ne)), slide(inc.ne)) && near(inc.ne.srcOut, inc.oe.srcOut + offOf(inc.ne));
+    const outOk = !out || (out.ne.recOut === nt.junction
+      && near(out.ne.srcOut - (out.oe.srcOut + offOf(out.ne)), slide(out.ne))
+      && near(out.ne.srcIn, out.oe.srcIn == null ? null : out.oe.srcIn + offOf(out.ne)));
+    if (!incOk || !outOk) continue;
+    const isMoveOfInc = (c) => c.kind === 'moved' && c.track === ot.track && c.oldRecIn === inc.oe.recIn && c.newRecIn === inc.ne.recIn;
+    const isTrimOfOut = (c) => out && c.kind === 'trimmed' && c.track === ot.track && c.oldRecIn === out.oe.recIn && c.newRecIn === out.ne.recIn;
+    const before = changes.length;
+    for (let i = changes.length - 1; i >= 0; i--) if (isMoveOfInc(changes[i]) || isTrimOfOut(changes[i])) changes.splice(i, 1);
+    if (changes.length === before && !P.pairs.includes(inc)) continue;
+    realigned.add(`${nt.track}|${nt.junction}`);
+    // Both sides show the same picture: they are retained cuts, not edits.
+    for (const pr of [inc, out]) if (pr && !retained.includes(pr.ne)) retained.push(pr.ne);
+    changes.push({
+      kind: 'junction_realigned', track: ot.track, oldRecIn: ot.junction, newRecIn: nt.junction, delta,
+      span: [nt.start, nt.end], outgoing: nt.outgoing, incoming: nt.incoming, type: nt.type, duration: nt.duration,
+    });
+  }
+
   // 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.
+  // travelled with its clips is the clips' move, already reported. Two
+  // labels for one effect family ("Cross Dissolve (Legacy)" in Premiere,
+  // "Cross Dissolve" in Resolve — E142) are a relabel, not a change.
+  const typeFamily = (t) => String(t ?? '').toLowerCase().replace(/\(legacy\)/g, '').replace(/^(video|audio)\s+/, '').replace(/\s+/g, ' ').trim();
+  const relabels = [];
   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 });
@@ -922,8 +1100,11 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
     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 (String(ot.type) !== String(nt.type)) {
+      if (typeFamily(ot.type) === typeFamily(nt.type)) relabels.push({ track: nt.track, junction: nt.junction, old: ot.type, new: nt.type });
+      else deltas.type = { old: ot.type, new: nt.type };
+    }
+    if (ot.pre !== nt.pre && !realigned.has(`${nt.track}|${nt.junction}`)) 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,
@@ -949,16 +1130,19 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
   // appeared with the cuts it joins) is a consequence, not an edit.
   const touches = (kind, junction, track) => changes.some((c) => c.kind === kind && c.track === track
     && ((kind === 'gone' ? [c.oldRecIn, c.oldRecOut] : [c.newRecIn, c.newRecOut]).some((v) => Math.abs((v ?? -1e9) - junction) <= recTol)));
-  const consequential = (c) => (c.kind === 'transition_dropped' && touches('gone', c.oldRecIn, c.track))
+  const consequential = (c) => c.kind === 'junction_realigned'
+    || (c.kind === 'transition_dropped' && touches('gone', c.oldRecIn, c.track))
     || (c.kind === 'transition_added' && touches('new', c.newRecIn, c.track));
   const edits = changes.filter((c) => c.kind !== 'gone' && c.kind !== 'new' && !consequential(c)).length;
   const gone = counts.gone || 0, added = counts.new || 0;
   const oldCuts = P.old.cuts.length + skipOld.size, newCuts = P.new.cuts.length + skipNew.size;
   let shape = 'edit';
   if (!changes.length) shape = 'identical';
+  else if (!edits && !gone && !added) shape = 'equivalent';
   else if (!edits && gone && !added && retained.length) shape = 'subset';
   else if (!edits && added && !gone && retained.length) shape = 'superset';
   const shapeInfo = { shape, retained: retained.length, oldCuts, newCuts };
+  if (shape === 'equivalent') shapeInfo.note = `same picture: ${counts.junction_realigned || 0} junction(s) re-aligned inside unchanged dissolves${relabels.length ? `, ${relabels.length} transition label(s) differ` : ''} — nothing edited`;
   if (shape === 'subset' || shape === 'superset') {
     const of = shape === 'subset' ? oldCuts : newCuts;
     shapeInfo.sparse = retained.length / Math.max(1, of) < 0.5;
@@ -972,7 +1156,10 @@ export function diffChangelist(oldEvents, newEvents, opts = {}) {
     transitions: { old: P.old.transitions.length, new: P.new.transitions.length },
     carriersFolded: { old: P.old.carriers.length, new: P.new.carriers.length },
     ...shapeInfo,
+    sourceTcOffsets: [...tcOffsets.values()].map((t) => ({ source: t.source, offset: t.offset, cuts: t.cuts, rebased: t.rebased })),
+    transitionRelabels: relabels.slice(0, 200),
     gate: 'review',
+    __P: P,
   };
 }
 

package/resolve-advanced/server/prproj.mjs

@@ -189,15 +189,24 @@ function realClipSource(clipNode, byId) {
   }
   const ms = srcEntry && asArray(srcEntry.node.MediaSource)[0];
   const media = ms && byId.get(ref(ms, 'Media') || '');
+  let generator = false;
   if (media) {
     const path = findFirstText(media.node, ['ActualMediaFilePath', 'FilePath', 'RelativePath'], 6);
-    if (path) name = String(path).split(/[\\/]/).pop();
+    // A synthetic Premiere item (Universal Counting Leader, Black Video, colour
+    // matte…) has NO file: its Media writes a bare numeric id as the path and
+    // carries the human name in <Title> (E141, measured: FilePath 1279607108 /
+    // Title "Universal Counting Leader"). Name it by the title and tag it a
+    // generator so a changelist pairs it with the online cut's generator by
+    // NAME instead of reporting a numeric id replaced.
+    const title = findFirstText(media.node, ['Title'], 3);
+    if (path && /^\d+$/.test(String(path).trim()) && title) { name = String(title); generator = true; }
+    else if (path) name = String(path).split(/[\\/]/).pop();
   }
   if (!name) {
     const master = byId.get(ref(sub.node, 'MasterClip') || '');
     name = (master && nodeName(master.node)) || nodeName(sub.node) || null;
   }
-  return { inPt, outPt, name };
+  return { inPt, outPt, name, generator };
 }
 
 function clipEvent(clipNode, byId, track, fps, index) {
@@ -225,6 +234,7 @@ function clipEvent(clipNode, byId, track, fps, index) {
     track,
     source: (real && real.name) || resolveSourceName(clipNode, byId),
     ...(real && real.nestedSequence ? { __nested: real.nestedSequence } : {}),
+    ...(real && real.generator ? { generatorName: real.name } : {}),
     srcIn: reverse ? srcOut : srcIn,
     srcOut: reverse ? srcIn : srcOut,
     recIn,

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

@@ -68,6 +68,9 @@ const changelistSchema = z.object({
   new: eventArray.describe('New (turnover) normalized events'),
   recTolerance: z.number().optional(),
   timingGuards: z.boolean().optional().describe('Also run the timing silent-lie guards (default true)'),
+  sourceAliases: z.array(z.object({ from: z.string().optional(), to: z.string().optional(), pattern: z.string().optional(), replace: z.string().optional(), flags: z.string().optional() })).optional()
+    .describe('Rename OLD sources before pairing (E141): {from,to} exact or {pattern,replace} regex — e.g. the offline "4K-2K" proxies vs the online "4K" masters. A systematic rename is also inferred automatically (inferAliases) and reported in sourceAliases.'),
+  inferAliases: z.boolean().optional().describe('Infer a systematic source rename from unpaired cuts that share a record window (default true)'),
 });
 
 const conformManifestSchema = z.object({
@@ -87,7 +90,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 OTIO generator clips (a Solid Color is a Clip with a NULL media_reference; it walks as a BL leg with generatorName, and an OTIO GeneratorReference carries its colour) and nested OTIO Stacks (compound clips — Resolve\'s writer nests them with a trim window) FLATTEN into record time with fromCompound on each cut, so Resolve\'s own OTIO exports re-conform (its FCP7 XML writer flattens a compound to ONE media-less clipitem instead — tagged `compound`, which the bridge drops with a reason in unresolvedCompounds unless the sourceMap maps the compound name to a flattened media file), Resolve-written FCP7 -1 junction edges (paired in record order) + Solid Color / Color Matte generators carrying their `fillcolor` (BL legs with `color` → fade-to-white and colour mattes author, E110), XMEML audio-track transitionitems as audio cross-fades on numbered lanes A/A2/…, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 (flat sound/picture slots number A/A2/… and V/V2/… in slot order so separate beds keep their lanes; NestedScope layers keep layer numbering; a NESTED SEQUENCE used as a clip — a SourceClip referencing a named CompositionMob — flattens through its reference window with fromCompound, like OTIO Stacks) + PRPROJ via gunzip+XML (real Premiere 2025 files — uuid ObjectUID/ObjectURef graph, TrackGroups, ClipTrackItem→SubClip→VideoClip→MediaSource→Media chain, zeros written as absence — and the legacy ObjectID/VideoTracks shape both walk; measured on a 739-sequence turnover that used to list ZERO; a NESTED SEQUENCE used as a clip — Source = Video/AudioSequenceSource → Sequence — flattens through its in-point window with fromCompound, like OTIO Stacks and AAF nested compositions; 13,711 such events on one real reels project; real transitions live in the track\'s TransitionItems list — read alongside ClipItems, attached with their DisplayName as type, HasOutgoingClip/HasIncomingClip false = fade from/to black or silence; tracks number as lanes V/V2…/A/A2… and a flattened nested sequence\'s inner lanes first-fit above what the parent already stacks — laneShift records the shift; markers are the sequence\'s OWN, read from Premiere\'s DVAMarker JSON) → 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/DRT/DRP pass the file PATH as content; DRT/DRP walk ONE timeline (`timeline` = pool name or index; default the first timeline-kind container) into events with sequence-relative record positions + the returned startFrame/startTimecode/fps read from the pool sequence — <In> is the source in-point (EMPTY on real audio clips → srcInAbsent), a keyed MediaTimemapBA Sm2TimeMap decodes to the speed (E140: the four retimed clips of a real reel read 80 — Premiere\'s 80 for the same cuts — with srcOut following the record window at that speed; XMax 60000 + zero slope = a freeze → the zero-speed in==out event; a negative slope = reverse; a map the decoder cannot read stays speed null + retimeUnknown, never faked to 100%), Sm2TiTransition alignment 2 centres on the cut and 3 ends at it — so two Resolve timeline VERSIONS diff through turnover_changelist (E139); 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 and nestedIn — an AAF composition another composition uses as a clip is NESTED in it; offer the parent, its cuts arrive flattened), 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 → a SHAPE verdict first — identical | subset (new keeps some of old\'s cuts unchanged in place and nothing else: a patch/selects reel of the same cut, NOT N deletions; a real Premiere auto-save kept 3 of 335) | superset (the reverse) | edit — with retained/oldCuts/newCuts, `sparse` and the retainedWindows for subset/superset, a transition that vanished or appeared with the cuts it joins counting as a consequence not an edit; then 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; a compound seen collapsed in one cut and flattened in the other reports compound_collapsed/compound_expanded once, never replaced+gone), 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; a compound clipitem fails source_resolved by NAME with the remedy — map it to a flattened file or turn over as OTIO), 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; COLOUR-AWARE: an input generator leg carrying a fillcolor (fade-to-white, colour matte) must come back on the same track over its span with the same colour — Resolve\'s FCP7 writer emits it — else generator-colour fails (generatorColours reports the compare) — pass exportedFormat: an OTIO/EDL re-export cannot carry colour (measured) and reports generatorColourNotInExport instead of failing; COMPOUND-AWARE: an XML re-export that collapsed a compound to one clipitem over cuts the input flattened from that compound reports compoundsCollapsedInExport instead of count/source drift; 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 OTIO generator clips (a Solid Color is a Clip with a NULL media_reference; it walks as a BL leg with generatorName, and an OTIO GeneratorReference carries its colour) and nested OTIO Stacks (compound clips — Resolve\'s writer nests them with a trim window) FLATTEN into record time with fromCompound on each cut, so Resolve\'s own OTIO exports re-conform (its FCP7 XML writer flattens a compound to ONE media-less clipitem instead — tagged `compound`, which the bridge drops with a reason in unresolvedCompounds unless the sourceMap maps the compound name to a flattened media file), Resolve-written FCP7 -1 junction edges (paired in record order) + Solid Color / Color Matte generators carrying their `fillcolor` (BL legs with `color` → fade-to-white and colour mattes author, E110), XMEML audio-track transitionitems as audio cross-fades on numbered lanes A/A2/…, and CMX FROM/TO CLIP NAME comments over the generic AX reel — + AAF via pyaaf2 (flat sound/picture slots number A/A2/… and V/V2/… in slot order so separate beds keep their lanes; NestedScope layers keep layer numbering; a NESTED SEQUENCE used as a clip — a SourceClip referencing a named CompositionMob — flattens through its reference window with fromCompound, like OTIO Stacks) + PRPROJ via gunzip+XML (real Premiere 2025 files — uuid ObjectUID/ObjectURef graph, TrackGroups, ClipTrackItem→SubClip→VideoClip→MediaSource→Media chain, zeros written as absence — and the legacy ObjectID/VideoTracks shape both walk; measured on a 739-sequence turnover that used to list ZERO; a NESTED SEQUENCE used as a clip — Source = Video/AudioSequenceSource → Sequence — flattens through its in-point window with fromCompound, like OTIO Stacks and AAF nested compositions; 13,711 such events on one real reels project; real transitions live in the track\'s TransitionItems list — read alongside ClipItems, attached with their DisplayName as type, HasOutgoingClip/HasIncomingClip false = fade from/to black or silence; tracks number as lanes V/V2…/A/A2… and a flattened nested sequence\'s inner lanes first-fit above what the parent already stacks — laneShift records the shift; markers are the sequence\'s OWN, read from Premiere\'s DVAMarker JSON) → 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/DRT/DRP pass the file PATH as content; DRT/DRP walk ONE timeline (`timeline` = pool name or index; default the first timeline-kind container) into events with sequence-relative record positions + the returned startFrame/startTimecode/fps read from the pool sequence — <In> is the source in-point (EMPTY on real audio clips → srcInAbsent), a keyed MediaTimemapBA Sm2TimeMap decodes to the speed (E140: the four retimed clips of a real reel read 80 — Premiere\'s 80 for the same cuts — with srcOut following the record window at that speed; XMax 60000 + zero slope = a freeze → the zero-speed in==out event; a negative slope = reverse; a map the decoder cannot read stays speed null + retimeUnknown, never faked to 100%), Sm2TiTransition alignment 2 centres on the cut and 3 ends at it — so two Resolve timeline VERSIONS diff through turnover_changelist (E139); 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 and nestedIn — an AAF composition another composition uses as a clip is NESTED in it; offer the parent, its cuts arrive flattened), 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 → a SHAPE verdict first — identical | subset (new keeps some of old\'s cuts unchanged in place and nothing else: a patch/selects reel of the same cut, NOT N deletions; a real Premiere auto-save kept 3 of 335) | superset (the reverse) | edit — with retained/oldCuts/newCuts, `sparse` and the retainedWindows for subset/superset, a transition that vanished or appeared with the cuts it joins counting as a consequence not an edit; RELINK-AWARE (E141): sourceAliases ({from,to} | {pattern,replace}) rename old sources before pairing, a systematic rename is INFERRED from unpaired cuts sharing a record window (one-to-one, recurring or clearly the same name) and reported in sourceAliases — a real offline→online turnover paired 15 of 228 cuts until the "4K-2K" proxies aliased to the "4K" masters, then 186 — and a constant per-source source-window shift witnessed on ≥2 cuts is a TC REBASE (sourceTcOffsets), not trims; a cut moved INSIDE an unchanged dissolve span with the incoming\'s source-in and the outgoing\'s source-out sliding by the same delta is ONE junction_realigned (E142: Premiere keeps a fractional alignment, Resolve\'s conform re-centres it — 9 of 10 residual moves on a real reel were this; same picture, a consequence not an edit) and two labels of one transition family ("Cross Dissolve (Legacy)" vs "Cross Dissolve") are a relabel in transitionRelabels, so a picture-identical conform reads shape `equivalent`; then 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; a compound seen collapsed in one cut and flattened in the other reports compound_collapsed/compound_expanded once, never replaced+gone), 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; a compound clipitem fails source_resolved by NAME with the remedy — map it to a flattened file or turn over as OTIO), 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; COLOUR-AWARE: an input generator leg carrying a fillcolor (fade-to-white, colour matte) must come back on the same track over its span with the same colour — Resolve\'s FCP7 writer emits it — else generator-colour fails (generatorColours reports the compare) — pass exportedFormat: an OTIO/EDL re-export cannot carry colour (measured) and reports generatorColourNotInExport instead of failing; COMPOUND-AWARE: an XML re-export that collapsed a compound to one clipitem over cuts the input flattened from that compound reports compoundsCollapsedInExport instead of count/source drift; 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);
@@ -147,7 +150,7 @@ export const editorialTool = {
     }
     if (action === 'turnover_changelist') {
       const p = changelistSchema.parse(args);
-      const result = diffChangelist(p.old, p.new, { recTolerance: p.recTolerance });
+      const result = diffChangelist(p.old, p.new, { recTolerance: p.recTolerance, sourceAliases: p.sourceAliases, inferAliases: p.inferAliases });
       if (p.timingGuards !== false) result.timing = timingGuards(p.old, p.new);
       return result;
     }

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.192.0"
+VERSION = "2.194.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.192.0"
+VERSION = "2.194.0"
 
 import base64
 import os