davinci-resolve-mcp 2.58.0 → 2.60.0

package/src/server.py

@@ -11,7 +11,7 @@ Usage:
     python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.58.0"
+VERSION = "2.60.0"
 
 import base64
 import os
@@ -745,6 +745,32 @@ resolve = None
 dvr_script = None
 _resolve_lock = threading.RLock()
 
+# On Windows the fusionscript native bridge DLL must be locatable before the
+# Python import machinery attempts to load it.  Setting PYTHONHOME, prepending
+# the Resolve install directory to PATH, and registering it with
+# os.add_dll_directory() ensures the dynamic loader can find fusionscript.dll
+# and its dependencies even when the server is launched from a virtual-env or
+# a working directory that is not the Resolve install directory.  These steps
+# MUST happen before `import DaVinciResolveScript` or the import triggers a
+# native access-violation on Windows (crash before port bind in network mode).
+if sys.platform.startswith("win") and RESOLVE_LIB_PATH:
+    _resolve_install_dir = os.path.dirname(RESOLVE_LIB_PATH)
+    if os.path.isdir(_resolve_install_dir):
+        # Ensure Python's own runtime DLLs are discoverable by the bridge.
+        if not os.environ.get("PYTHONHOME"):
+            os.environ["PYTHONHOME"] = sys.base_prefix
+        # Prepend Resolve's install dir to PATH so the loader finds
+        # fusionscript.dll and sibling DLLs even without a system-wide install.
+        _cur_path = os.environ.get("PATH", "")
+        if _resolve_install_dir.lower() not in _cur_path.lower():
+            os.environ["PATH"] = _resolve_install_dir + os.pathsep + _cur_path
+        # os.add_dll_directory is available on Python 3.8+ (Windows only).
+        if hasattr(os, "add_dll_directory"):
+            try:
+                os.add_dll_directory(_resolve_install_dir)
+            except OSError:
+                pass
+
 try:
     import DaVinciResolveScript as dvr_script
     logger.info("DaVinciResolveScript module loaded")
@@ -4340,6 +4366,7 @@ _TIMELINE_CONFORM_KERNEL_ACTIONS = [
     "source_range_report",
     "export_timeline_checked",
     "import_timeline_checked",
+    "import_from_drp",
     "compare_timelines",
     "probe_interchange_roundtrip",
     "detect_missing_media",
@@ -5345,18 +5372,108 @@ def _timeline_media_coverage(tl) -> Dict[str, Any]:
     return {"total": total, "linked": linked, "offline": total - linked}
 
 
+def _collect_media_pool_items(tl):
+    """Unique Media Pool Items referenced by a timeline's items (for RelinkClips)."""
+    items = []
+    seen = set()
+    for track_type in ("video", "audio"):
+        try:
+            count = int(tl.GetTrackCount(track_type) or 0)
+        except Exception:
+            count = 0
+        for i in range(1, count + 1):
+            for item in (tl.GetItemListInTrack(track_type, i) or []):
+                try:
+                    mpi = item.GetMediaPoolItem()
+                except Exception:
+                    mpi = None
+                if mpi is not None and id(mpi) not in seen:
+                    seen.add(id(mpi))
+                    items.append(mpi)
+    return items
+
+
+def _binary_post_import_relink(tl, mp, search_roots):
+    """Fuzzy-relink parity for binary interchange (AAF): after import, ask Resolve's media pool
+    to relink the timeline's Media Pool Items against each search root. This is the media-pool
+    analogue of the XML path-rewrite relink (which can't run on a binary file)."""
+    roots = [r for r in (search_roots or []) if isinstance(r, str) and os.path.isdir(r)]
+    if not roots:
+        return {"attempted": False, "reason": "no existing search roots", "roots": search_roots or []}
+    items = _collect_media_pool_items(tl)
+    if not items:
+        return {"attempted": False, "reason": "no Media Pool Items to relink", "roots": roots}
+    before = _timeline_media_coverage(tl)
+    calls = []
+    for root in roots:
+        try:
+            ok = bool(mp.RelinkClips(items, root))
+            calls.append({"root": root, "ok": ok})
+        except Exception as e:
+            calls.append({"root": root, "ok": False, "error": str(e)})
+    after = _timeline_media_coverage(tl)
+    return {
+        "attempted": True,
+        "roots": roots,
+        "item_count": len(items),
+        "calls": calls,
+        "before": before,
+        "after": after,
+        "linked_delta": after["linked"] - before["linked"],
+    }
+
+
+_PRPROJ_REFUSAL = (
+    "Resolve has no native .prproj importer (Premiere's project format is gzip-compressed "
+    "XML, not an interchange). Two offline routes, no Premiere needed: (1) read it with the "
+    "advanced MCP — editorial.list_sequences / editorial.parse_interchange (format 'prproj'); "
+    "(2) convert it to an importable interchange — editorial.convert_to_interchange "
+    "(target 'otio'|'edl'|'drt') — then import that here with import_timeline_checked. "
+    "Editorial timing/cuts/transitions/speed carry over; per-clip effects/Lumetri color do not. "
+    "Alternatively export FCP7 XML / AAF / FCPXML from Premiere and conform that."
+)
+
+# Binary interchange formats Resolve reads NATIVELY — the XML sanitize/relink pass
+# (which parses the file as text) does not apply. Relinking happens via the media
+# pool after import, not by rewriting the file.
+_BINARY_INTERCHANGE_EXTS = {".aaf"}
+
+
 def _import_timeline_checked(proj, mp, p: Dict[str, Any]):
     path = p.get("path")
     if not path:
         return _err("path is required")
     if not os.path.exists(path):
         return _err(f"path does not exist: {path}")
+    ext = os.path.splitext(path)[1].lower()
+    if ext == ".prproj":
+        return _err(_PRPROJ_REFUSAL, category="invalid_input")
+    # AAF (and any binary interchange) is read natively by Resolve. The XML
+    # sanitize/relink path parses the file as text, so it must be SKIPPED for AAF
+    # even when sanitize_media / relink_search_roots is passed; fuzzy XML relink is
+    # N/A (media links through the media pool). We still detect the created
+    # (possibly offline) timeline via the before/after id diff.
+    is_binary = ext in _BINARY_INTERCHANGE_EXTS
     # sanitize_media (alias: relink_media) rewrites the XML to drop clipitems that
     # reference missing media or are generators (slug/solid w/ no pathurl) — both
     # abort Resolve's scripting-API import and leave the timeline fully offline.
     # The original is only read; the sanitized copy lands in a temp dir, so the
     # temp-path guard never applies to it.
-    sanitize = bool(p.get("sanitize_media") or p.get("relink_media"))
+    sanitize_requested = bool(p.get("sanitize_media") or p.get("relink_media"))
+    binary_relink_note = None
+    _binary_has_roots = bool(p.get("relink_search_roots") or p.get("search_roots"))
+    if is_binary and _binary_has_roots:
+        binary_relink_note = (
+            f"XML path-rewrite relink is N/A for {ext} (binary) — imported as-is, then relinked "
+            "via the media pool against the search roots (see `relink`)."
+        )
+    elif is_binary and sanitize_requested:
+        binary_relink_note = (
+            f"sanitize_media is N/A for {ext} (binary) — Resolve reads it natively and media "
+            "relinks via the media pool. Imported the file as-is; pass relink_search_roots to "
+            "auto-relink after import."
+        )
+    sanitize = sanitize_requested and not is_binary
     if not sanitize and p.get("require_temp_path", True) and not _render_temp_path_ok(path):
         return _err(
             "path must be under the system temp directory unless require_temp_path=False",
@@ -5375,7 +5492,7 @@ def _import_timeline_checked(proj, mp, p: Dict[str, Any]):
     search_roots = p.get("relink_search_roots") or p.get("search_roots")
     if isinstance(search_roots, str):
         search_roots = [search_roots]
-    if search_roots and not sanitize:
+    if search_roots and not sanitize and not is_binary:
         sanitize = True  # relinking is meaningless without the sanitize/rewrite pass
 
     sanitize_report = None
@@ -5412,6 +5529,8 @@ def _import_timeline_checked(proj, mp, p: Dict[str, Any]):
         out = _ok(path=path, import_path=import_path, options=options, would_import=True)
         if sanitize_report is not None:
             out["sanitize"] = sanitize_report
+        if binary_relink_note:
+            out["note"] = binary_relink_note
         return out
 
     before_ids = set()
@@ -5432,15 +5551,32 @@ def _import_timeline_checked(proj, mp, p: Dict[str, Any]):
             if t and str(t.GetUniqueId()) not in before_ids:
                 imported = t
     if not imported:
+        if is_binary:
+            remediation = (
+                f"Resolve created no timeline from this {ext}. Verify it exports/opens in "
+                "Resolve directly, or convert to FCP7 XML / FCPXML upstream and import that."
+            )
+        elif sanitize:
+            remediation = None
+        else:
+            remediation = (
+                "This XML may reference missing media or contain generator clips, which "
+                "abort the scripting-API import. Retry with sanitize_media=True."
+            )
         return _err(
             "Failed to import timeline (Resolve created no timeline)",
-            remediation=None if sanitize else
-            "This XML may reference missing media or contain generator clips, which "
-            "abort the scripting-API import. Retry with sanitize_media=True.",
+            remediation=remediation,
         )
 
     imported_id = str(imported.GetUniqueId())
     media = _timeline_media_coverage(imported)
+    # AAF fuzzy-relink parity: when search roots are given for a binary import, relink through
+    # the media pool after import (the XML path-rewrite relink can't run on a binary file).
+    relink_result = None
+    if is_binary and search_roots:
+        relink_result = _binary_post_import_relink(imported, mp, search_roots)
+        if relink_result.get("after"):
+            media = relink_result["after"]
     out = _ok(
         name=imported.GetName(),
         id=imported_id,
@@ -5451,15 +5587,166 @@ def _import_timeline_checked(proj, mp, p: Dict[str, Any]):
     )
     if sanitize_report is not None:
         out["sanitize"] = sanitize_report
+    if relink_result is not None:
+        out["relink"] = relink_result
+    if binary_relink_note:
+        out["note"] = binary_relink_note
     if media["total"] and media["offline"]:
         msg = f"{media['offline']} of {media['total']} timeline items are offline (no linked media)."
-        if not sanitize:
+        if is_binary:
+            msg += (" Relink via the media pool (right-click → Relink Clips) or point Resolve "
+                    "at the media roots — AAF media links there, not by rewriting the file.")
+        elif not sanitize:
             msg += (" Retry with sanitize_media=True to drop missing-media/generator "
                     "clips so the remaining media links automatically.")
         out["warning"] = msg
     return out
 
 
+# A .drp/.drt is a zip of SeqContainer*.xml entries. Two on-disk naming conventions,
+# mirroring the Node drt-format parser: tool-authored `<folder>/SeqContainer<N>.xml`
+# and real-Resolve `SeqContainer/<uuid>.xml`. Never match MpFolder/project/Gallery.
+_SEQ_CONTAINER_RE = re.compile(r"(^|/)SeqContainer(\d*\.xml|/[^/]+\.xml)$")
+
+
+def _drp_seq_containers(zf) -> List[Dict[str, Any]]:
+    """List a .drp/.drt zip's SeqContainers as [{entry, name, index}] (0-based, sorted)."""
+    entries = sorted(n for n in zf.namelist() if not n.endswith("/") and _SEQ_CONTAINER_RE.search(n))
+    out = []
+    for index, entry in enumerate(entries):
+        try:
+            xml = zf.read(entry).decode("utf-8", "replace")
+        except Exception:
+            xml = ""
+        m = re.search(r"<Name>([\s\S]*?)</Name>", xml)
+        out.append({"entry": entry, "name": (m.group(1).strip() if m else None), "index": index})
+    return out
+
+
+def _extract_seqcontainer_from_drp(drp_path: str, seq_entry: str, out_path: str) -> None:
+    """Write a minimal .drt (zip) holding one SeqContainer as Primary1/SeqContainer1.xml."""
+    import zipfile
+
+    with zipfile.ZipFile(drp_path, "r") as zf:
+        xml = zf.read(seq_entry)
+    with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as out:
+        out.writestr("Primary1/SeqContainer1.xml", xml)
+        out.writestr(
+            "metadata.json",
+            json.dumps(
+                {
+                    "source": "import_from_drp",
+                    "sourceDrp": drp_path,
+                    "sourceSeqContainer": seq_entry,
+                    "exportedFrom": "davinci-resolve-mcp timeline.import_from_drp",
+                },
+                indent=2,
+            ),
+        )
+
+
+def _import_from_drp(proj, mp, p: Dict[str, Any]):
+    """
+    Extract the chosen timelines from a .drp (offline zip surgery) and import each into the
+    running Resolve. Requires Resolve open. Mirrors: drt.extract_from_drp → import_timeline_checked,
+    but as one call returning per-timeline results.
+    """
+    import zipfile
+
+    drp_path = p.get("drpPath") or p.get("drp_path") or p.get("path")
+    if not drp_path:
+        return _err("drpPath is required")
+    if not os.path.exists(drp_path):
+        return _err(f"drpPath does not exist: {drp_path}")
+    ext = os.path.splitext(drp_path)[1].lower()
+    if ext == ".prproj":
+        return _err(_PRPROJ_REFUSAL, category="invalid_input")
+
+    try:
+        with zipfile.ZipFile(drp_path, "r") as zf:
+            containers = _drp_seq_containers(zf)
+    except zipfile.BadZipFile:
+        return _err(f"Not a valid .drp/.drt (not a zip archive): {drp_path}", category="invalid_input")
+    if not containers:
+        return _err(f"No SeqContainer entries found in {drp_path} — is this a .drp/.drt?", category="invalid_input")
+
+    # Selection: by name(s), by 0-based index(es), or ALL when neither is given.
+    want_names = p.get("timelineNames") or p.get("timeline_names")
+    if isinstance(want_names, str):
+        want_names = [want_names]
+    want_indexes = p.get("timelineIndexes") or p.get("timeline_indexes")
+    if isinstance(want_indexes, int):
+        want_indexes = [want_indexes]
+
+    selected: List[Dict[str, Any]] = []
+    available = [{"name": c["name"], "index": c["index"]} for c in containers]
+    if want_names:
+        by_name = {}
+        for c in containers:
+            if c["name"]:
+                by_name.setdefault(c["name"], c)
+        for nm in want_names:
+            c = by_name.get(nm)
+            if not c:
+                return _err(
+                    f"Timeline named {nm!r} not found in .drp",
+                    remediation=f"Available: {[a['name'] for a in available]}",
+                    category="invalid_input",
+                )
+            selected.append(c)
+    elif want_indexes:
+        for i in want_indexes:
+            match = next((c for c in containers if c["index"] == int(i)), None)
+            if not match:
+                return _err(f"timelineIndex {i} out of range (0..{len(containers) - 1})", category="invalid_input")
+            selected.append(match)
+    else:
+        selected = list(containers)
+
+    # Per-timeline options passthrough (importSourceClips etc.) minus selection keys.
+    base = {
+        k: v
+        for k, v in p.items()
+        if k not in ("drpPath", "drp_path", "path", "timelineNames", "timeline_names", "timelineIndexes", "timeline_indexes", "dry_run")
+    }
+
+    tmp_dir = tempfile.mkdtemp(prefix="drp_import_")
+    results = []
+    imported_count = 0
+    for c in selected:
+        safe = re.sub(r"[^A-Za-z0-9._-]+", "_", c["name"] or f"seq{c['index'] + 1}")
+        drt_path = os.path.join(tmp_dir, f"{c['index'] + 1}_{safe}.drt")
+        entry = {"requested": c["name"], "index": c["index"]}
+        try:
+            _extract_seqcontainer_from_drp(drp_path, c["entry"], drt_path)
+        except Exception as e:
+            entry.update(success=False, error=f"extract failed: {e}")
+            results.append(entry)
+            continue
+        if p.get("dry_run"):
+            entry.update(success=True, would_import=True, drt_path=drt_path)
+            results.append(entry)
+            continue
+        sub = dict(base)
+        sub["path"] = drt_path
+        # .drt lives under a temp dir; the temp-path guard passes regardless.
+        res = _import_timeline_checked(proj, mp, sub)
+        ok = bool(res.get("success"))
+        entry.update(res)
+        if ok:
+            imported_count += 1
+        results.append(entry)
+
+    return _ok(
+        drpPath=drp_path,
+        selected=len(selected),
+        imported=imported_count,
+        available=available,
+        results=results,
+        dry_run=bool(p.get("dry_run")),
+    )
+
+
 def _timeline_by_selector(proj, p: Dict[str, Any], *, prefix: str):
     timeline_id = p.get(f"{prefix}_timeline_id") or p.get(f"{prefix}_id")
     timeline_index = p.get(f"{prefix}_timeline_index") or p.get(f"{prefix}_index")
@@ -17619,6 +17906,47 @@ def _edit_engine_capture(tl) -> Dict[str, Any]:
     return out
 
 
+def _compact_structural_diff(diff: Any, *, sample_n: int = 3) -> Any:
+    """Trim a compare_usage_snapshots result for the default execute response.
+
+    The full added/removed/moved/trimmed rows (one per timeline item, each with
+    media_pool_item_id + track + in/out frames) dominate large tighten
+    responses — 226 KB for a 130-segment tighten (issue #84). The counts already
+    live in `summary`; keep those plus a small head/tail sample per change kind.
+    The full diff is persisted in the executed plan record (edit_engine
+    get_plan(plan_id) → plan.execution_summary.structural_diff) and returned
+    inline when the caller passes include_details=true.
+    """
+    if not isinstance(diff, dict):
+        return diff
+    # An error stand-in (diff failed) or an already-compact payload: pass through.
+    if "summary" not in diff:
+        return diff
+    sample: Dict[str, Any] = {}
+    omitted = 0
+    for kind in ("added", "removed", "moved", "trimmed"):
+        rows = diff.get(kind)
+        if not isinstance(rows, list) or not rows:
+            continue
+        if len(rows) <= sample_n:
+            sample[kind] = list(rows)
+            continue
+        # Head sample + final row so the caller sees both ends of the change set.
+        sample[kind] = list(rows[: sample_n - 1]) + [rows[-1]]
+        omitted += len(rows) - sample_n
+    return {
+        "summary": diff.get("summary"),
+        "sample": sample,
+        "truncated": True,
+        "omitted_rows": omitted,
+        "detail_hint": (
+            "Full per-item diff persisted in the plan record — retrieve via "
+            "edit_engine get_plan(plan_id) → plan.execution_summary.structural_diff, "
+            "or re-run with include_details=true to inline it."
+        ),
+    }
+
+
 def _edit_engine_track_counts(tl) -> Dict[str, int]:
     """Per-track-type item counts — the swap symmetry signal in readback."""
     counts: Dict[str, int] = {}
@@ -17740,9 +18068,12 @@ def edit_engine(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
       evidence for the current (or named) timeline. Kept ranges mirror onto the
       items' linked audio tracks by default so the variant is audible; pass
       include_audio=false for a video-only (silent) assembly.
-    - execute_tighten(plan_id, confirm_token?) — assembles a tightened VARIANT
-      timeline from the plan's keep ranges (video + mirrored audio), never
-      mutating the original. Readback includes an audio_accounting block.
+    - execute_tighten(plan_id, confirm_token?, include_details?) — assembles a
+      tightened VARIANT timeline from the plan's keep ranges (video + mirrored
+      audio), never mutating the original. Readback includes an audio_accounting
+      block and a compact structural_diff (counts + a small sample); the full
+      per-item diff is persisted in the plan record (get_plan → execution_summary)
+      and returned inline only when include_details=true.
     - plan_swap(track_index?, timeline_start_frame | item_name, kind?, limit?)
       — alternates for one timeline item via the similarity index.
     - execute_swap(plan_id, alternate_index, confirm_token?) — replaces the
@@ -17900,7 +18231,10 @@ def edit_engine(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
                 build_errors.append({"index": i, "error": row_err.get("error")})
                 continue
             built.append(row)
-            record_cursor += int(append_ci.get("end_frame", 0)) - int(append_ci.get("start_frame", 0)) + 1
+            # AppendToTimeline endFrame is exclusive: the item occupies
+            # (end - start) frames. Advancing by +1 more leaves a 1-frame gap
+            # (black flash) between consecutive selects. See api_truth endFrame entry.
+            record_cursor += int(append_ci.get("end_frame", 0)) - int(append_ci.get("start_frame", 0))
         appended = mp.AppendToTimeline(built) if built else None
         readback = _edit_engine_capture(tl)
         # A diff against a source timeline is meaningless for a fresh assembly;
@@ -18030,12 +18364,20 @@ def edit_engine(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
             )
         except Exception:
             pass
+        # The full per-item structural diff is persisted in the plan record so it
+        # stays retrievable (edit_engine get_plan) without bloating every
+        # response — see issue #84. The MCP response carries a compact form by
+        # default and the full diff only when include_details=true.
+        include_details = _media_analysis_bool(
+            p.get("include_details", p.get("includeDetails")), False
+        )
         _edit_engine_mod.mark_plan_executed(project_root, plan["plan_id"], {
             "variant_timeline": variant.get("name") or variant_name,
             "keep_ranges": len(keep_ranges),
             "lifts": len(lifts),
             "before": before,
             "after": after,
+            "structural_diff": structural_diff,
         })
         return {
             "success": True,
@@ -18055,7 +18397,10 @@ def edit_engine(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[st
                     if before.get("duration_seconds") is not None and after.get("duration_seconds") is not None
                     else None
                 ),
-                "structural_diff": structural_diff,
+                "structural_diff": (
+                    structural_diff if include_details
+                    else _compact_structural_diff(structural_diff)
+                ),
                 "audio_accounting": {
                     "planned_audio_ranges": audio_keep_ranges,
                     "planned_video_ranges": video_keep_ranges,
@@ -18366,7 +18711,14 @@ def timeline(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str,
       source_range_report(handles?, merge?) -> {ranges, occurrences}
       export_timeline_checked(path, format?|type?, subtype?, require_temp_path?, dry_run?) -> {success, path, size}
       import_timeline_checked(path, options?, timeline_name?, import_source_clips?, sanitize_media?, require_temp_path?, dry_run?) -> {success, name, id, media, sanitize?, warning?}
-        Imports an FCP7 xmeml / FCPXML timeline. `media` reports {total, linked, offline}
+        Imports an FCP7 xmeml / FCPXML / AAF timeline. AAF (.aaf) is read natively by
+        Resolve — the XML sanitize pass is SKIPPED for it (media relinks via the media
+        pool, not by rewriting the file); a `note` says so. For AAF, passing
+        relink_search_roots triggers a POST-import media-pool relink (RelinkClips against
+        each root) — fuzzy-relink parity by a media-pool mechanism; the `relink` block
+        reports before/after coverage. Premiere .prproj has no Resolve importer — refused
+        with a message pointing to the advanced MCP's offline read + convert_to_interchange
+        bridge (no Premiere needed). `media` reports {total, linked, offline}
         coverage; `warning` flags offline items. sanitize_media=True (recommended for
         Premiere/FCP exports) rewrites the XML first — dropping clipitems that reference
         MISSING media or are generators (slug/solid with no media file), both of which
@@ -18384,6 +18736,11 @@ def timeline(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str,
         metric; a conflicting relink is VETOED — reverted and reported under
         `sanitize.flagged` for human review, never silently applied. verify_threshold
         (default 0.90) sets the structural-match bar.
+      import_from_drp(drpPath, timelineNames?|timelineIndexes?, import_source_clips?, dry_run?) -> {success, selected, imported, available, results}
+        Extract chosen timelines from a .drp (offline zip surgery → temp .drt each) and
+        import each into the running Resolve. Omit the selector to import ALL. Enumerate
+        first with the advanced MCP drt.list_sequences / editorial.list_sequences to get
+        [{id, name, eventCount}] for a "which sequence?" picker. Requires Resolve open.
       compare_timelines(right_timeline_id?|right_timeline_index?|left_snapshot?, right_snapshot?) -> {match, differences}
       probe_interchange_roundtrip(format?, output_dir?, cleanup_imported?) -> {success, export, import, comparison}
       detect_missing_media(sanitized?|sanitize_paths?, omit_raw_paths?) -> {missing, missing_count, diagnosis}
@@ -18438,6 +18795,11 @@ def timeline(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str,
         if mp_err:
             return mp_err
         return _import_timeline_checked(proj, mp, p)
+    elif action == "import_from_drp":
+        _, _, mp, mp_err = _get_mp()
+        if mp_err:
+            return mp_err
+        return _import_from_drp(proj, mp, p)
     elif action == "safe_auto_sync_audio":
         _, _, mp, mp_err = _get_mp()
         if mp_err:

package/src/utils/api_truth.py

@@ -508,6 +508,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,