davinci-resolve-mcp 4.1.2 → 4.2.0

package/CHANGELOG.md

@@ -2,6 +2,147 @@
 
 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 v4.2.0 — the raw grade-copy asks before it overwrites, and an injected grade shows as graded
+
+Contributed by [@Rohitkanithi](https://github.com/Rohitkanithi) in
+[#231](https://github.com/samuelgursky/davinci-resolve-mcp/pull/231), plus a
+fix to the offline `.drp` grade-injection tier.
+
+### Added
+
+- **`timeline_item_color copy_grades` now takes a `confirm_token` and requires
+  one before it calls `TimelineItem.CopyGrades`.** The raw action reaches an API
+  that replaces the target's entire node graph with the source's, with no
+  recovery version — reconfirmed on Studio 21.1.0.14 in
+  [#207](https://github.com/samuelgursky/davinci-resolve-mcp/issues/207), where
+  the target's exported grade became byte-identical to the source and the
+  version list stayed `['Version 1']` throughout. Until now the trap
+  acknowledgement was the only barrier, and acknowledging a trap is a statement
+  about understanding the API, not about the clips in front of you.
+
+  The first call now returns `confirmation_required` with a preview built from
+  the targets it actually resolved — how many, which IDs, and which IDs were not
+  found on any video track — and a one-time token bound to the action and a
+  fingerprint of the params. Change `target_ids` after receiving the token and
+  the token no longer matches. The trap gate still runs first, so the sequence is
+  acknowledge, inspect the resolved targets, then commit. The safe siblings
+  (`safe_copy_grade`, `bulk_match_to_hero`) already gated their own writes; this
+  closes the raw path that bypassed them.
+
+  A side effect of routing target resolution through the existing
+  `_timeline_items_for_grade_copy` helper: IDs that resolve to nothing are now
+  **reported** rather than silently dropped, which is the "No target existence
+  check" the action's own docstring had been warning about.
+
+### Fixed
+
+- **An injected grade rendered correctly but the Color page listed the clip as
+  ungraded.** Resolve decides "graded" from the per-version `<HasCorrection>`
+  element beside the `Body`, not from the body bytes. `injectGrades` replaced the
+  `Body` and left the flag as it found it, so on a 352-clip balance pass the
+  grades were live while the page showed them missing. The version element lists
+  `HasCorrection` before `Body`, so the last `HasCorrection` preceding the
+  replaced `Body` is the owner's; it is now flipped to true and untouched clips
+  keep their flag. The test builds an ungraded two-clip DRP, injects one, and
+  asserts the target reads true while the sibling still reads false, with an
+  already-corrected fixture as the null control.
+
+### Validation
+
+- Full offline suite on the merged result: **3,620 passed, 1 skipped,
+  1,257 subtests passed, zero failures.** The `drp-format` Node tests pass
+  (8 passed, 1 skipped), including the new `HasCorrection` case.
+- All release drift guards green, including `test_write_enforcement_ratchet`,
+  `test_doc_tool_counts`, `test_action_list_drift` and
+  `test_release_surface_drift`.
+- No Resolve live run: the confirm-token gate is server-side control flow, and
+  the `.drp` change is offline file authoring covered by its own round-trip test.
+  Neither alters what Resolve is asked to do once a call is allowed through.
+
+## What's New in v4.1.3 — every live harness could no longer start, and a probe that could never pass
+
+Reported and measured by [@legionsound](https://github.com/legionsound) in
+[#207](https://github.com/samuelgursky/davinci-resolve-mcp/issues/207) while
+running `color_grade_live_probe` on Studio 21.1.0.14. No server behaviour
+changes; the harnesses that verify Resolve's behaviour do.
+
+### Fixed
+
+- **Every hand-run live harness failed at import, on every machine**, with
+  `ImportError: cannot import name 'Context' from 'mcp.server.fastmcp'` at
+  `src/server.py:240`. Seventeen harnesses each carried a private copy of a stub
+  installer, and the copies were wrong in two independent ways:
+
+  - They called `sys.modules.setdefault("mcp", stub)` *before* anything had
+    imported `mcp`, so the stand-ins displaced the **real, working SDK** on
+    machines that had it. The stub set was never a fallback in practice; it was
+    always what ran.
+  - `src/server.py` grew `Context`, `Image` and `mcp.types`; fifteen of the
+    seventeen copies still offered only `FastMCP`. Each harness died at whichever
+    import its own copy had never been taught about.
+
+  There is now one installer, `src/utils/mcp_import_stubs.py`, which **imports
+  the real package first and leaves it alone**, and only stands in when the SDK
+  is genuinely absent. All seventeen call it; 648 lines of divergent copies are
+  gone. `tests/test_mcp_import_stubs.py` reads the SDK imports back out of
+  `src/server.py` and fails when the stub set falls behind, or when a harness
+  hand-rolls its own again — both regressions were re-introduced deliberately to
+  confirm the guard catches them.
+
+- **`safe_copy_grade` and `safe_apply_drx` could never pass in the probe.** Both
+  are rated destructive, so the first call returns `CONFIRMATION_REQUIRED` and a
+  one-time token *instead of acting*. The probe predates confirm tokens, called
+  once, and recorded the prompt as the action's outcome — two permanent errors in
+  a report whose purpose is to notice change. It now answers the gate and records
+  what the action actually did, repeating the params the token's fingerprint is
+  bound to.
+
+### Changed
+
+- **`TimelineItem.ApplyGradeFromStill` is now re-measured rather than trusted.**
+  It was the one #217 entry the probe never exercised — a claim that a method
+  does *not* exist, which nothing would notice Blackmagic reversing. The check
+  uses `dir()` membership and sanity-checks the enumeration against a method
+  known to exist before treating an absence as evidence.
+
+- **Corrected an api_truth entry that implied `hasattr` is safe on Resolve's own
+  objects.** It is not. Measured here on Studio 19.1.3.7:
+  `hasattr(timeline_item, 'TotallyMadeUpName')` returns `True`, as does `hasattr`
+  for `ApplyGradeFromStill`, while `dir()` on the same object lists 84 real names
+  and neither of those. Resolve fabricates a callable for **any** attribute name
+  on **every** object, not only Fusion Tools; what is special about Fusion Tools
+  is that `dir()` is unreliable there too, leaving no usable probe at all. A
+  capability check written on `hasattr` reports every method as present.
+
+### Reconfirmed
+
+Three of the four trap entries from
+[#217](https://github.com/samuelgursky/davinci-resolve-mcp/pull/217) were
+independently re-measured on Studio 21.1.0.14 by a second contributor, and now
+carry it. This matters most for `TimelineItem.CopyGrades`, which is the entry
+that makes a mapped action refuse without `acknowledge_trap`:
+
+- **`TimelineItem.CopyGrades`** — returned `True`; the target's exported grade
+  became byte-identical to the source's; `GetVersionNameList` read
+  `['Version 1']` before and after, so there is still no recovery version.
+- **`TimelineItem.ExportLUT`** — wrote a file only from `color`; `deliver`,
+  `edit`, `fairlight`, `fusion` and `media` all returned `False` and left no
+  stale files.
+- **`Timeline.DuplicateTimeline`** — the current-timeline pointer moved to the
+  duplicate, and `SetCurrentTimeline` put it back.
+
+`TimelineItem.ApplyGradeFromStill` stays **reported**, not reconfirmed — that
+probe run did not exercise it. The check added above closes that gap for the
+next run.
+
+### Validation
+
+Full suite green: 3,616 passed, 1 skipped, 1,257 subtests. The count rises by
+exactly the three new guard tests. No live Resolve run beyond the read-only
+attribute measurement quoted above, taken on Studio 19.1.3.7 — the harness
+changes are import-path and gate-protocol fixes, verified against the real
+token machinery offline.
+
 ## What's New in v4.1.2 — the installer's healthy-branch test stops depending on a live Resolve
 
 Test-only. No behaviour change to the server or the installer.

package/README.md

@@ -2,7 +2,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-[![Version](https://img.shields.io/badge/version-4.1.2-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-4.2.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-37%20(387%20full)-blue.svg)](#server-modes)

package/README.zh-CN.md

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

package/docs/reference/api-limitations.md

@@ -455,8 +455,8 @@ values, or automation-hostile modal prompts.
 
 - **Object:** `Fusion Tool / Composition`
 - **Signature:** `dir(tool) -> incomplete list`
-- **Behavior:** `dir()` on a live Fusion Tool returns 38 names — with 'Composition' listed TWICE — and omits GetAttrs and SetAttrs, which are documented Fusion Tool methods that work perfectly when called. Measured on free 21.0.3.7 over the in-app bridge: invoking GetAttrs directly returned {TOOLS_Name: 'Blur1', TOOLS_RegID: 'Blur'} and SetAttrs renamed the tool. This matters because Resolve fabricates a callable for ANY attribute name, so `dir()` is the only evidence of absence that exists — which makes an omitted name unrecoverable by probing. Any capability detection built on dir()/hasattr will therefore report a real Fusion method as missing. Resolve's own API objects do not have this problem: Timeline (60), TimelineItem (88) and Composition (92) all enumerate correctly.
-- **Workaround / current handling:** Do not treat dir()/hasattr as authoritative for Fusion Tool objects. Keep a curated set of documented Fusion methods that the enumeration omits, and identify a Fusion object positively (ConnectInput / FindMainInput / GetControlPageNames on a Tool, AddTool / FindTool / GetToolList on a Composition) rather than relaxing the check globally, which would silently re-open capability detection on Resolve API objects.
+- **Behavior:** `dir()` on a live Fusion Tool returns 38 names — with 'Composition' listed TWICE — and omits GetAttrs and SetAttrs, which are documented Fusion Tool methods that work perfectly when called. Measured on free 21.0.3.7 over the in-app bridge: invoking GetAttrs directly returned {TOOLS_Name: 'Blur1', TOOLS_RegID: 'Blur'} and SetAttrs renamed the tool. This matters because Resolve fabricates a callable for ANY attribute name, so `dir()` is the only evidence of absence that exists — which makes an omitted name unrecoverable by probing. Any capability detection built on dir()/hasattr will therefore report a real Fusion method as missing. Resolve's own API objects enumerate correctly — Timeline (60), TimelineItem (88) and Composition (92) — so the INCOMPLETE ENUMERATION is Fusion's alone. The fabrication is not: measured on Studio 19.1.3.7, `hasattr(timeline_item, 'TotallyMadeUpName')` returns True, and so does hasattr for a method that genuinely does not exist (ApplyGradeFromStill), while dir() on the same object lists 84 real names and neither of those. So hasattr/getattr is worthless for absence on EVERY Resolve object, Fusion or not; what is special about Fusion Tools is that dir() is wrong there too, leaving no reliable probe at all.
+- **Workaround / current handling:** Never use hasattr/getattr to test whether ANY Resolve object has a method — it always says yes. Use dir() membership, and sanity-check the enumeration with a method you know exists before trusting an absence. For Fusion Tool objects not even dir() is authoritative: keep a curated set of documented Fusion methods that the enumeration omits, and identify a Fusion object positively (ConnectInput / FindMainInput / GetControlPageNames on a Tool, AddTool / FindTool / GetToolList on a Composition) rather than relaxing the check globally, which would silently re-open capability detection on Resolve API objects.
 - **Tags:** fusion, introspection, bridge, free-edition
 
 ### Composition.Lock (suppresses render invalidation for value writes)

package/install.py

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

package/resolve-advanced/vendor/drp-format/__tests__/inject-grades.test.js

@@ -244,3 +244,39 @@ test('injectGrades: internals — extractDrxBodyHex throws on missing Body', ()
 test.skip('injectGrades: rendered frame matches direct DRX apply '
   + '(covered by tests/live_drp_roundtrip_verification.py — grade-render compare still TODO)',
 () => {});
+
+test('injectGrades: flips the owning version\'s HasCorrection to true (Resolve reads the flag, not the body)', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'inject-hc-'));
+  const src = path.join(dir, 'src.drp');
+  const out = path.join(dir, 'out.drp');
+  const buf = await drpFormat.buildDRP({
+    projectName: 'inject-hc-test',
+    timelines: [{
+      name: 'T1', frameRate: 24, startTimecode: '01:00:00:00', resolution: '1920x1080',
+      videoTracks: [{ clips: [
+        { start: 0, duration: 24, in: 0, mediaFilePath: '/synthetic/a.mov', grade: { body: BASELINE_BODY, hasCorrection: false, versionName: 'V1' } },
+        { start: 24, duration: 24, in: 0, mediaFilePath: '/synthetic/b.mov', grade: { body: ORIGINAL_BODY_CLIP_2, hasCorrection: false, versionName: 'V1' } },
+      ] }],
+      audioTracks: [],
+    }],
+  });
+  await fs.writeFile(src, buf);
+  const before = await readSeqContainer(src);
+  assert.equal((before.match(/<HasCorrection>true<\/HasCorrection>/g) || []).length, 0, 'fixture starts ungraded');
+  const ids = [...before.matchAll(/<(?:Sm2TiVideoClip|Sm2VideoClip)[^>]*?DbId="([^"]+)"/g)].map((m) => m[1]);
+  assert.equal(ids.length, 2);
+  await drpFormat.injectGrades(src, [{ clipId: ids[0], drxContent: makeSyntheticDrx(INJECTED_BODY) }], { outputPath: out });
+  const after = await readSeqContainer(out);
+  const clipBlock = (xml, id) => {
+    const i = xml.indexOf(`DbId="${id}"`);
+    const j = xml.indexOf('</Sm2TiVideoClip>', i);
+    return xml.slice(i, j);
+  };
+  assert.match(clipBlock(after, ids[0]), /<HasCorrection>true<\/HasCorrection>/, 'targeted clip is now marked corrected');
+  assert.match(clipBlock(after, ids[0]), new RegExp(`<Body>${INJECTED_BODY}</Body>`));
+  assert.match(clipBlock(after, ids[1]), /<HasCorrection>false<\/HasCorrection>/, 'untouched clip keeps its flag');
+  assert.doesNotMatch(clipBlock(after, ids[1]), /<HasCorrection>true/);
+  // Null control: injecting into an already-corrected version changes nothing but the body.
+  const already = await readSeqContainer(src);
+  assert.equal((already.match(/<HasCorrection>/g) || []).length, 2);
+});

package/resolve-advanced/vendor/drp-format/inject-grades.js

@@ -56,7 +56,8 @@ function extractDrxBodyHex(drxContent) {
  *
  * Scoping: the regex anchors on `<Sm2TiVideoClip ... DbId="<id>"` and
  * runs forward to the matching `</Sm2TiVideoClip>`. Inside that range we
- * replace exactly one <Body>HEX</Body>. If a clip has no Body yet (a
+ * replace exactly one <Body>HEX</Body> and flip the owning version's
+ * <HasCorrection> to true. If a clip has no Body yet (a
  * brand-new clip with no grade) we don't synthesize the surrounding
  * LmVersionTable scaffolding — that's a builder responsibility, not an
  * injector one. Callers wanting to add grades to clean clips should
@@ -100,12 +101,32 @@ function replaceBodyForClip(seqXml, targetDbId, newBodyHex) {
   // 3. Within the clip's range, replace exactly one <Body>...</Body>.
   const clipRange = seqXml.slice(openStart, clipEnd);
   const bodyRe = /<Body>([\s\S]*?)<\/Body>/;
-  if (!bodyRe.test(clipRange)) return null;
-  const newClipRange = clipRange.replace(
+  const bodyAt = clipRange.search(bodyRe);
+  if (bodyAt < 0) return null;
+  let newClipRange = clipRange.replace(
     bodyRe,
     `<Body>${newBodyHex}</Body>`,
   );
 
+  // 4. Mark the owning version as corrected. Resolve keeps a per-version
+  //    <HasCorrection> flag beside the Body and its UI reads THAT (clip strip
+  //    "graded"/"ungraded", clip filters), not the body bytes — a body
+  //    injected into a version left at false renders the grade but shows the
+  //    clip as ungraded (JREG2, 2026-09-13). The version element lists
+  //    HasCorrection before Body, so the last HasCorrection preceding the
+  //    replaced Body is the owner's.
+  const head = newClipRange.slice(0, bodyAt);
+  const hcAt = head.lastIndexOf('<HasCorrection>');
+  if (hcAt >= 0) {
+    const hcEnd = head.indexOf('</HasCorrection>', hcAt);
+    if (hcEnd > hcAt) {
+      newClipRange =
+        head.slice(0, hcAt) +
+        '<HasCorrection>true</HasCorrection>' +
+        newClipRange.slice(hcEnd + '</HasCorrection>'.length);
+    }
+  }
+
   return seqXml.slice(0, openStart) + newClipRange + seqXml.slice(clipEnd);
 }
 

package/src/granular/common.py

@@ -87,7 +87,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "4.1.2"
+VERSION = "4.2.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 377-tool granular server instead
 """
 
-VERSION = "4.1.2"
+VERSION = "4.2.0"
 
 import base64
 import os
@@ -28657,8 +28657,8 @@ def timeline_item_color(action: str, params: Optional[Dict[str, Any]] = None) ->
     Raw mutators (UNSAFE direct mutation — prefer the safe_* sibling):
       set_cdl(cdl, ...) -> {success}
         UNSAFE. No validation; no dry_run. Prefer safe_set_cdl.
-      copy_grades(target_ids, ...) -> {success}
-        UNSAFE. No target existence check. Prefer safe_copy_grade.
+      copy_grades(target_ids, confirm_token?, ...) -> {success}
+        UNSAFE. Replaces target grades and is confirm-token gated. Prefer safe_copy_grade.
       export_lut(type, path, ...) -> {success}
         UNSAFE. No path sandboxing. Prefer safe_export_lut.
       reset_all_node_colors(...) -> {success}
@@ -28738,14 +28738,23 @@ def timeline_item_color(action: str, params: Optional[Dict[str, Any]] = None) ->
     elif action == "copy_grades":
         # Find target items by IDs
         _, tl, _ = _get_tl()
-        targets = []
-        target_ids = set(p["target_ids"])
+        target_ids = p["target_ids"]
         if tl:
-            for tt in ["video"]:
-                for ti in range(1, tl.GetTrackCount(tt) + 1):
-                    for it in (tl.GetItemListInTrack(tt, ti) or []):
-                        if it.GetUniqueId() in target_ids:
-                            targets.append(it)
+            targets, missing = _timeline_items_for_grade_copy(tl, target_ids)
+        else:
+            targets, missing = [], sorted(set(target_ids or []))
+        if "confirm_token" not in p and "confirmToken" not in p and _confirm_token_required():
+            preview = {
+                "operation": "timeline_item_color.copy_grades",
+                "warning": "Replaces the entire node graph on every successfully resolved target item.",
+                "target_count": len(targets),
+                "target_ids": [target.GetUniqueId() for target in targets],
+                "missing": missing,
+            }
+            return _issue_confirm_token(action="timeline_item_color.copy_grades", params=p, preview=preview)
+        blocked = _consume_confirm_token(action="timeline_item_color.copy_grades", params=p)
+        if blocked:
+            return blocked
         return {"success": bool(item.CopyGrades(targets))}
     elif action == "add_version":
         return {"success": bool(item.AddVersion(p["name"], p.get("type", 0)))}

package/src/utils/api_truth.py

@@ -422,11 +422,23 @@ API_TRUTH: List[Dict[str, Any]] = [
                    "evidence of absence that exists — which makes an omitted "
                    "name unrecoverable by probing. Any capability detection "
                    "built on dir()/hasattr will therefore report a real Fusion "
-                   "method as missing. Resolve's own API objects do not have "
-                   "this problem: Timeline (60), TimelineItem (88) and "
-                   "Composition (92) all enumerate correctly.",
-        "recommended": "Do not treat dir()/hasattr as authoritative for Fusion "
-                       "Tool objects. Keep a curated set of documented Fusion "
+                   "method as missing. Resolve's own API objects enumerate "
+                   "correctly — Timeline (60), TimelineItem (88) and "
+                   "Composition (92) — so the INCOMPLETE ENUMERATION is Fusion's "
+                   "alone. The fabrication is not: measured on Studio 19.1.3.7, "
+                   "`hasattr(timeline_item, \'TotallyMadeUpName\')` returns True, "
+                   "and so does hasattr for a method that genuinely does not "
+                   "exist (ApplyGradeFromStill), while dir() on the same object "
+                   "lists 84 real names and neither of those. So hasattr/getattr "
+                   "is worthless for absence on EVERY Resolve object, Fusion or "
+                   "not; what is special about Fusion Tools is that dir() is "
+                   "wrong there too, leaving no reliable probe at all.",
+        "recommended": "Never use hasattr/getattr to test whether ANY Resolve "
+                       "object has a method — it always says yes. Use dir() "
+                       "membership, and sanity-check the enumeration with a "
+                       "method you know exists before trusting an absence. For "
+                       "Fusion Tool objects not even dir() is authoritative: "
+                       "keep a curated set of documented Fusion "
                        "methods that the enumeration omits, and identify a "
                        "Fusion object positively (ConnectInput / FindMainInput "
                        "/ GetControlPageNames on a Tool, AddTool / FindTool / "
@@ -3296,6 +3308,14 @@ API_TRUTH: List[Dict[str, Any]] = [
         "tags": ["destructive", "unrecoverable", "grade", "no-version"],
         "destroys_prior_work": True,
         "verified_on": "DaVinci Resolve Studio 21.1.0.14",
+        "reconfirmed": "2026-09-13: independently re-measured on 21.1.0.14 by a "
+                       "second contributor running color_grade_live_probe. "
+                       "CopyGrades returned True; the target's exported grade "
+                       "became byte-identical to the source's (same digest on "
+                       "both); GetVersionNameList read ['Version 1'] before and "
+                       "after, so there is still no recovery version. This is the "
+                       "entry that makes acknowledge_trap refuse, so it is the one "
+                       "that most needed a second pair of hands.",
     },
     {
         "symbol": "TimelineItem.ApplyGradeFromStill",
@@ -3326,6 +3346,11 @@ API_TRUTH: List[Dict[str, Any]] = [
         "tags": ["page-gated", "silent-failure", "lut"],
         "submit": "bug",
         "verified_on": "DaVinci Resolve Studio 21.1.0.14",
+        "reconfirmed": "2026-09-13: independently re-measured on 21.1.0.14 by a "
+                       "second contributor. Returned True and wrote a file only "
+                       "from color; deliver, edit, fairlight, fusion and media all "
+                       "returned False and wrote nothing, with no stale files left "
+                       "behind on the failing pages.",
     },
     {
         "symbol": "Timeline.DuplicateTimeline",
@@ -3344,6 +3369,9 @@ API_TRUTH: List[Dict[str, Any]] = [
                        "already does this and fails loudly if the restore fails.",
         "tags": ["side-effect", "silent-failure", "timeline"],
         "verified_on": "DaVinci Resolve Studio 21.1.0.14",
+        "reconfirmed": "2026-09-13: independently re-measured on 21.1.0.14 by a "
+                       "second contributor. The current-timeline pointer moved to "
+                       "the duplicate, and SetCurrentTimeline put it back.",
     },
 
 ]

package/src/utils/color_grade_live_probe.py

@@ -61,6 +61,35 @@ def _record_tool_result(
     recorder.record(category, name, expected_status or "supported", evidence=result)
 
 
+def _call_confirmed(tool, action: str, params: Dict[str, Any]) -> Dict[str, Any]:
+    """Call a destructive action, answering the confirmation gate if it fires.
+
+    Actions rated destructive answer the first call with
+    `status="confirmation_required"` and a one-time token instead of acting. This
+    probe is an operator-run harness whose whole purpose is to perform these
+    mutations on a disposable project, so it answers the prompt rather than
+    recording the prompt as the action's outcome — which is what it used to do,
+    leaving `safe_copy_grade` and `safe_apply_drx` permanently unpassable.
+
+    The token is minted against a fingerprint of (action, params) with
+    `confirm_token` stripped, so the second call must repeat the same params.
+    """
+    result = tool(action, params)
+    if not isinstance(result, dict):
+        return result
+    token = result.get("confirm_token")
+    if result.get("status") != "confirmation_required" or not token:
+        return result
+
+    confirmed = tool(action, {**params, "confirm_token": token})
+    if isinstance(confirmed, dict):
+        confirmed["confirmation_gate"] = {
+            "fired": True,
+            "preview": result.get("preview"),
+        }
+    return confirmed
+
+
 def _run_ffmpeg(args: list[str]) -> None:
     subprocess.run(["ffmpeg", "-hide_banner", "-loglevel", "error", *args], check=True)
 
@@ -328,6 +357,62 @@ def _verify_duplicatetimeline_moves_pointer(recorder, project, timeline) -> None
         recorder.record("api_truth", "DuplicateTimeline_moves_current", "error", details=details)
 
 
+def _verify_applygradefromstill_absent(recorder, items) -> None:
+    """TimelineItem.ApplyGradeFromStill: is it still absent?
+
+    The entry for this one is a claim that a method does NOT exist, and a probe
+    that only re-measures behaviours leaves it as folklore — nothing notices the
+    day Blackmagic ships it. An absence is cheap to re-measure, so it is checked
+    here rather than trusted.
+
+    Measured with `dir()`, never `hasattr`. Resolve fabricates a callable for any
+    attribute name you ask for, on its own API objects and not just Fusion ones:
+    on Studio 19.1.3.7 `hasattr(item, "TotallyMadeUpName")` is True. A hasattr
+    check here would report this method "restored" on every run, forever. `dir()`
+    on a TimelineItem enumerates honestly (84 real names on that build), so it is
+    the only usable evidence of absence.
+    """
+    if not items:
+        recorder.record("api_truth", "ApplyGradeFromStill_absent", "not_applicable",
+                        details={"reason": "probe timeline has no items"})
+        return
+
+    item = items[0]
+    try:
+        names = dir(item)
+        present = "ApplyGradeFromStill" in names
+        control = "CopyGrades" in names
+    except Exception as exc:  # noqa: BLE001
+        recorder.record_exception("api_truth", "ApplyGradeFromStill_absent", exc)
+        return
+
+    details = {
+        "present_on_timelineitem": present,
+        "enumerated_names": len(names),
+        "control_copygrades_enumerated": control,
+        "measured_with": "dir() — hasattr fabricates callables on Resolve objects",
+        "api_truth_claims": "TimelineItem.ApplyGradeFromStill does not exist",
+    }
+    if not control:
+        # dir() stopped enumerating usefully; absence proves nothing here.
+        details["reason"] = (
+            "CopyGrades is missing from dir() too, so this object is not "
+            "enumerating — the absence of ApplyGradeFromStill is not evidence."
+        )
+        recorder.record("api_truth", "ApplyGradeFromStill_absent", "not_applicable", details=details)
+        return
+    if not present:
+        recorder.record("api_truth", "ApplyGradeFromStill_absent", "supported", details=details)
+        return
+
+    details["drifted"] = (
+        "ApplyGradeFromStill now exists on TimelineItem. The api_truth entry "
+        "calling it missing is stale — measure what it does before anyone "
+        "relies on it."
+    )
+    recorder.record("api_truth", "ApplyGradeFromStill_absent", "error", details=details)
+
+
 def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, Any]:
     output_dir.mkdir(parents=True, exist_ok=True)
     work_dir = Path(tempfile.mkdtemp(prefix="mcp_color_grade_probe_"))
@@ -478,7 +563,11 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
                 recorder,
                 "copy",
                 "safe_copy_grade",
-                server.timeline_item_color("safe_copy_grade", {**scope, "target_ids": [target_id]}),
+                _call_confirmed(
+                    server.timeline_item_color,
+                    "safe_copy_grade",
+                    {**scope, "target_ids": [target_id]},
+                ),
             )
         else:
             recorder.record("copy", "safe_copy_grade", "not_applicable", details={"reason": "No second video item"})
@@ -590,7 +679,7 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
                 recorder,
                 "drx",
                 "safe_apply_drx",
-                server.timeline_item_color("safe_apply_drx", apply_params),
+                _call_confirmed(server.timeline_item_color, "safe_apply_drx", apply_params),
             )
         else:
             recorder.record("drx", "safe_apply_drx", "not_applicable", details={"reason": "No DRX was exported by gallery probe"})
@@ -607,6 +696,7 @@ def run_probe(server, output_dir: Path, keep_open: bool = False) -> Dict[str, An
         _verify_copygrades_replaces_wholesale(recorder, resolve, items, work_dir)
         _verify_exportlut_page_gate(recorder, server, resolve, items, work_dir)
         _verify_duplicatetimeline_moves_pointer(recorder, project, timeline)
+        _verify_applygradefromstill_absent(recorder, items)
 
         if keep_open:
             server.project_manager("save")

package/src/utils/mcp_import_stubs.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""Stand-ins for the `mcp` package, for live harnesses that import `src.server`.
+
+`src.server` imports the MCP SDK at module scope, so a live harness cannot reach
+the tool functions without it. Harnesses used to each carry a private copy of a
+stub installer, and every copy drifted: `src.server` grew `Context`, `Image` and
+`mcp.types`, the copies kept offering only `FastMCP`, and each one broke at the
+import it had never been taught about.
+
+Two rules keep that from recurring:
+
+1. **Never stub over a real package.** The old copies called
+   `sys.modules.setdefault(...)` before anything had imported `mcp`, so the
+   stand-ins won on machines where the genuine SDK was installed and working.
+   `install_mcp_stubs()` imports the real package first and leaves it alone.
+2. **One stub set, checked against its consumer.** `MCP_STUB_NAMES` records what
+   the stubs provide; `tests/test_mcp_import_stubs.py` reads the `mcp` imports
+   out of `src/server.py` and fails when the server starts needing a name the
+   stubs do not define.
+"""
+
+from __future__ import annotations
+
+import sys
+import types
+from typing import Dict, Tuple
+
+# What the stub set provides, per module. The drift guard compares this against
+# the names `src/server.py` actually imports, so adding an import there without
+# teaching the stubs about it fails a test instead of a live run.
+MCP_STUB_NAMES: Dict[str, Tuple[str, ...]] = {
+    "mcp": ("types",),
+    "mcp.server": (),
+    "mcp.server.fastmcp": ("Context", "FastMCP", "Image"),
+    "mcp.server.stdio": ("stdio_server",),
+    "mcp.types": ("ToolAnnotations", "ImageContent", "TextContent"),
+}
+
+
+def _real_mcp_is_importable() -> bool:
+    """True when the genuine SDK is installed and exposes what the server needs."""
+    try:
+        import mcp  # noqa: F401
+        from mcp import types as _real_types  # noqa: F401
+        from mcp.server.fastmcp import Context, FastMCP, Image  # noqa: F401
+    except Exception:
+        return False
+    return True
+
+
+def _build_stub_modules(*, stdio_note: str) -> Dict[str, types.ModuleType]:
+    class FastMCP:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def _decorator(self, *args, **kwargs):
+            def decorate(func):
+                return func
+
+            return decorate
+
+        tool = _decorator
+        resource = _decorator
+        prompt = _decorator
+
+    class Context:
+        pass
+
+    class Image:
+        def __init__(self, *args, **kwargs):
+            pass
+
+    class ToolAnnotations:
+        def __init__(self, *args, **kwargs):
+            pass
+
+    def stdio_server(*args, **kwargs):
+        raise RuntimeError(stdio_note)
+
+    anyio = types.ModuleType("anyio")
+    anyio.run = lambda func: func()
+
+    mcp = types.ModuleType("mcp")
+    server = types.ModuleType("mcp.server")
+    fastmcp = types.ModuleType("mcp.server.fastmcp")
+    stdio = types.ModuleType("mcp.server.stdio")
+    mcp_types = types.ModuleType("mcp.types")
+
+    fastmcp.FastMCP = FastMCP
+    fastmcp.Context = Context
+    fastmcp.Image = Image
+    stdio.stdio_server = stdio_server
+    mcp_types.ToolAnnotations = ToolAnnotations
+    mcp_types.ImageContent = object
+    mcp_types.TextContent = object
+    mcp.types = mcp_types
+
+    return {
+        "anyio": anyio,
+        "mcp": mcp,
+        "mcp.server": server,
+        "mcp.server.fastmcp": fastmcp,
+        "mcp.server.stdio": stdio,
+        "mcp.types": mcp_types,
+    }
+
+
+def install_mcp_stubs(*, stdio_note: str = "stdio_server is not used by this live harness") -> bool:
+    """Make `import src.server` work, without displacing a working MCP SDK.
+
+    Returns True when stand-ins were installed, False when the real package was
+    found and left in place — so a harness can say which one it ran against.
+    """
+    if _real_mcp_is_importable():
+        return False
+
+    for name, module in _build_stub_modules(stdio_note=stdio_note).items():
+        sys.modules.setdefault(name, module)
+    return True

package/src/utils/timeline_kernel_live_probe.py

@@ -20,7 +20,6 @@ import tempfile
 
 from src.utils.resolve_probe import has_method
 import time
-import types
 import traceback
 from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional, Tuple
@@ -101,43 +100,17 @@ EXTRA_TIMELINE_ITEM_METHODS = [
 
 
 def _install_mcp_stubs() -> None:
-    """Allow importing src.server when MCP deps are absent from Python 3.11."""
+    """Stand in for the MCP SDK only when it is genuinely absent.
 
-    class FastMCP:
-        def __init__(self, *args, **kwargs):
-            pass
-
-        def tool(self, *args, **kwargs):
-            def decorate(func):
-                return func
-
-            return decorate
-
-        def resource(self, *args, **kwargs):
-            def decorate(func):
-                return func
-
-            return decorate
-
-    def stdio_server(*args, **kwargs):
-        raise RuntimeError("stdio_server is not used by the live timeline kernel probe")
-
-    anyio = types.ModuleType("anyio")
-    anyio.run = lambda func: func()
-
-    mcp = types.ModuleType("mcp")
-    server = types.ModuleType("mcp.server")
-    fastmcp = types.ModuleType("mcp.server.fastmcp")
-    stdio = types.ModuleType("mcp.server.stdio")
-
-    fastmcp.FastMCP = FastMCP
-    stdio.stdio_server = stdio_server
+    Delegates to the shared installer so this harness cannot drift behind the
+    imports `src.server` actually makes; see `src/utils/mcp_import_stubs.py`.
+    """
+    repo_root = str(Path(__file__).resolve().parents[2])
+    if repo_root not in sys.path:
+        sys.path.insert(0, repo_root)
+    from src.utils.mcp_import_stubs import install_mcp_stubs
 
-    sys.modules.setdefault("anyio", anyio)
-    sys.modules.setdefault("mcp", mcp)
-    sys.modules.setdefault("mcp.server", server)
-    sys.modules.setdefault("mcp.server.fastmcp", fastmcp)
-    sys.modules.setdefault("mcp.server.stdio", stdio)
+    install_mcp_stubs(stdio_note="stdio_server is not used by this live harness")
 
 
 def _require_success(label: str, result: Dict[str, Any]) -> Dict[str, Any]: