davinci-resolve-mcp 2.69.0 → 2.69.1

package/CHANGELOG.md

@@ -2,6 +2,49 @@
 
 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.69.1
+
+Bug fix. The Studio bridge differential no longer reports the Deliver page its
+own render probes navigated to as a transport difference.
+
+### Fixed
+
+- **A clean bridge produced a red result on any run that did not start on
+  Deliver.** Run live on Studio 19.1.3.7, the differential reported
+  `resolve.GetCurrentPage` as a `value_mismatch` — bridge `edit`, native
+  `deliver` — and it reproduced on command: start on Edit, one difference; start
+  on Deliver, none. The transport was never involved. The harness's own render
+  probes navigate Resolve to the Deliver page, and the bridge pass runs before
+  the native pass, so the native pass read a page the bridge pass had moved. Read
+  at the same instant the two transports always agreed.
+
+  Adding the method to `VOLATILE_METHODS` would have turned red green and thrown
+  away the signal — a bridge that genuinely reports the wrong page is exactly
+  what this harness exists to catch. Instead each pass now records the page on
+  the way in and on the way out, and the value is compared **only when both
+  passes prove it held still**. If both were stable and the values still
+  disagree, that is the transport, and it is reported as before. A page that
+  cannot be read counts as unknown rather than stable, so an unreadable page
+  disables the comparison instead of quietly restoring the false positive.
+
+  `page_compared_by_value` and both passes' before/after values now ride in the
+  report either way. "The page was not compared" is a fact about the run, and
+  burying it would recreate the silence this fixes.
+
+### Added
+
+- `tests/test_bridge_differential.py` — the module's first tests, 13 of them,
+  including the one that matters: a stable page that genuinely disagrees must
+  still be reported, or the fix is a mute button rather than a fix. The absence
+  of any coverage here is why the false positive shipped.
+
+### Validation
+
+- Static checks and the full unit suite: 2243 → 2256 tests, pyflakes clean.
+- Live Resolve validation on Studio 19.1.3.7 after the fix: 142 probes, 0
+  differences, 110/112 read methods, started from the Edit page that previously
+  failed.
+
 ## What's New in v2.69.0
 
 The free edition is documented as reachable, silence ripple stops clipping

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.69.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.69.1-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-34%20(341%20full)-blue.svg)](#server-modes)

package/install.py

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

package/src/granular/common.py

@@ -85,7 +85,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.69.0"
+VERSION = "2.69.1"
 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 341-tool granular server instead
 """
 
-VERSION = "2.69.0"
+VERSION = "2.69.1"
 
 import base64
 import os

package/src/utils/bridge_differential.py

@@ -61,6 +61,28 @@ VOLATILE_METHODS = frozenset({
     "IsPlayheadOnVideoFrame",
 })
 
+#: App-global state that **the harness's own probes move**, which is a different
+#: problem from `VOLATILE_METHODS` drifting on its own.
+#:
+#: Measured on Studio 19.1.3.7: the render probes navigate Resolve to the Deliver
+#: page, and the bridge pass runs before the native pass — so the native pass
+#: reads a page the bridge pass changed. That produced a `value_mismatch` on
+#: `GetCurrentPage` (bridge `edit`, native `deliver`) on every run that did not
+#: happen to start on Deliver, and none on the runs that did. Read at the same
+#: instant the two transports always agreed.
+#:
+#: Excusing it unconditionally would throw away a real signal — a bridge that
+#: genuinely reported the wrong page is exactly the bug this harness is for. So
+#: each pass records the page on the way in and on the way out, and the value is
+#: only excused when a pass proves it did not hold still. If both passes were
+#: stable and the values still disagree, that is the transport and it is reported.
+ORDER_SENSITIVE_METHODS = frozenset({"GetCurrentPage"})
+
+#: Key `run_probes` adds for `compare`'s own use rather than as a probe result.
+#: Underscore-prefixed so the diff skips it instead of reading it as a method
+#: that one transport has and the other does not.
+PASS_META_KEY = "_pass_meta"
+
 #: Never invoked by the harness, whatever the enumeration says. These either
 #: change the project, touch the filesystem, or block on UI. The write paths are
 #: exercised by named scenarios instead, where the setup and teardown are
@@ -326,6 +348,19 @@ def probe_one(target: Any, method: str) -> Dict[str, Any]:
     return {"outcome": "returned", "value": normalise(value), "type": describe(value)}
 
 
+def _current_page(resolve: Any) -> Optional[str]:
+    """The page, or None if it cannot be read.
+
+    Never raises: this is bookkeeping around the probes, and a failure here must
+    not take down a pass that is otherwise fine.
+    """
+    try:
+        page = resolve.GetCurrentPage()
+    except Exception:  # noqa: BLE001 - an unreadable page is simply unknown
+        return None
+    return page if isinstance(page, str) else None
+
+
 def run_probes(resolve: Any, methods: Sequence[str]) -> Dict[str, Dict[str, Any]]:
     """Every enumerated safe method, against every object that has it.
 
@@ -333,6 +368,7 @@ def run_probes(resolve: Any, methods: Sequence[str]) -> Dict[str, Dict[str, Any]
     not merely that they did.
     """
     results: Dict[str, Dict[str, Any]] = {}
+    page_before = _current_page(resolve)
     for label, chain in OBJECT_GRAPH:
         target = walk(resolve, chain)
         if target is None:
@@ -342,13 +378,28 @@ def run_probes(resolve: Any, methods: Sequence[str]) -> Dict[str, Dict[str, Any]
             if getattr(target, method, None) is None:
                 continue  # not on this object; absence is reported by the diff
             results[f"{label}.{method}"] = probe_one(target, method)
+    page_after = _current_page(resolve)
+    results[PASS_META_KEY] = {
+        "page_before": page_before,
+        "page_after": page_after,
+        # None on either side means we could not tell, which must not read as
+        # "stable" — an unknown has to disable the value comparison, not enable it.
+        "page_stable": page_before is not None and page_before == page_after,
+    }
     return results
 
 
 def compare(native: Dict[str, Dict[str, Any]], bridged: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
     """Diff two probe runs. Empty `differences` is the pass condition."""
     differences: List[Dict[str, Any]] = []
+    # A pass that moved the page cannot have its page compared by value against
+    # another pass taken at a different moment. Both must have held still.
+    native_meta = native.get(PASS_META_KEY) or {}
+    bridge_meta = bridged.get(PASS_META_KEY) or {}
+    page_held_still = bool(native_meta.get("page_stable")) and bool(bridge_meta.get("page_stable"))
     for key in sorted(set(native) | set(bridged)):
+        if key.startswith("_"):
+            continue  # harness bookkeeping, not a probe result
         left, right = native.get(key), bridged.get(key)
         if left is None or right is None:
             differences.append({
@@ -364,17 +415,32 @@ def compare(native: Dict[str, Dict[str, Any]], bridged: Dict[str, Dict[str, Any]
                 differences.append({"key": key, "kind": "volatile_type_mismatch",
                                     "native": left.get("type"), "bridge": right.get("type")})
             continue
+        if method in ORDER_SENSITIVE_METHODS and not page_held_still:
+            # The harness moved it mid-run, so the two readings are of different
+            # moments. Still hold the transport to returning the same kind of
+            # thing, and say why the value was not compared.
+            if left.get("type") != right.get("type") or left["outcome"] != right["outcome"]:
+                differences.append({"key": key, "kind": "order_sensitive_type_mismatch",
+                                    "native": left.get("type"), "bridge": right.get("type")})
+            continue
         if left != right:
             differences.append({"key": key, "kind": "value_mismatch",
                                 "native": left, "bridge": right})
-    agreed = len(set(native) & set(bridged)) - len(
+    probe_keys = {k for k in set(native) | set(bridged) if not k.startswith("_")}
+    agreed = len({k for k in set(native) & set(bridged) if not k.startswith("_")}) - len(
         [d for d in differences if d["kind"] != "only_one_transport_reached_it"]
     )
     return {
-        "compared": len(set(native) | set(bridged)),
+        "compared": len(probe_keys),
         "agreed": agreed,
         "differences": differences,
         "identical": not differences,
+        # Reported either way. "The page was not compared" is a fact about the
+        # run that a reader needs, and burying it would recreate the silence
+        # this fix exists to end.
+        "page_compared_by_value": page_held_still,
+        "page_native": {k: native_meta.get(k) for k in ("page_before", "page_after")},
+        "page_bridge": {k: bridge_meta.get(k) for k in ("page_before", "page_after")},
     }