davinci-resolve-mcp 2.52.0 → 2.52.1

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 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.52.1
+
+Analysis reuse no longer blocks on missing capabilities when every clip is
+satisfied by an existing report (issue #68). `build_plan` records
+`capability_gaps` from the *requested* options before the per-clip reuse
+decision runs; when a fully-reused plan only re-keys and imports existing
+reports into the current root, no fresh transcription/vision/ffprobe happens,
+so the missing-capability gate must not fire.
+
+- **Fixed** the missing-capability gate is now evaluated against the clips that
+  still need fresh analysis, not the requested-options gaps. A clip is exempt
+  only when it both skips execution and has an existing report path; any clip
+  needing fresh work still enforces the gate.
+- **Fixed** extended the exemption to the entry points that short-circuit
+  before `execute_plan_async` and were still blocking fully-reused runs: the
+  `media_analysis` analyze action, metadata-publish analysis, and batch-job
+  creation. The batch CLI `plan` preview no longer prints "Missing tools" for a
+  fully-reusable plan.
+- **Changed** the reuse/capability logic is now a shared
+  `plan_requires_capabilities()` / `executing_clips()` helper, replacing the
+  duplicated inline comprehensions so every gate stays consistent.
+- Includes PR #68 by @diesdaas, which fixed the inner `execute_plan_async` gate
+  and isolated the marker-param and host-vision tests from unrelated
+  capability/destructive-hook coupling.
+
 ## What's New in v2.52.0
 
 `edit_engine` tighten now carries audio. Previously `execute_tighten`

package/README.md

@@ -1,6 +1,6 @@
 # DaVinci Resolve MCP Server
 
-[![Version](https://img.shields.io/badge/version-2.52.0-blue.svg)](https://github.com/samuelgursky/davinci-resolve-mcp/releases)
+[![Version](https://img.shields.io/badge/version-2.52.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

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

package/src/batch_cli.py

@@ -17,6 +17,7 @@ from typing import Any, Dict, List, Optional
 from src.utils.media_analysis import (
     build_plan,
     detect_capabilities,
+    plan_requires_capabilities,
 )
 from src.utils.media_analysis_jobs import (
     batch_job_status,
@@ -187,7 +188,7 @@ def _cmd_plan(args: argparse.Namespace) -> int:
             f"Est. seconds : {plan.get('estimated_seconds_after_reuse', '?')}",
             json_mode=False,
         )
-        if plan.get("capability_gaps"):
+        if plan.get("capability_gaps") and plan_requires_capabilities(plan):
             _emit(f"Missing tools: {plan['capability_gaps']}", json_mode=False)
         for w in warnings:
             _emit(f"  warning: {w}", json_mode=False)

package/src/granular/common.py

@@ -80,7 +80,7 @@ if not logging.getLogger().handlers:
         handlers=[logging.StreamHandler()],
     )
 
-VERSION = "2.52.0"
+VERSION = "2.52.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.52.0"
+VERSION = "2.52.1"
 
 import base64
 import os
@@ -77,6 +77,7 @@ from src.utils.media_analysis import (
     execute_plan_async as execute_media_analysis_plan_async,
     install_guidance as media_analysis_install_guidance,
     load_report as load_media_analysis_report,
+    plan_requires_capabilities as media_analysis_plan_requires_capabilities,
     query_analysis_index,
     resolve_output_root as resolve_media_analysis_output_root,
     short_hash,
@@ -9226,7 +9227,7 @@ async def _publish_clip_metadata_from_analysis(
         )
         if not plan.get("success"):
             return plan
-        if plan.get("capability_gaps"):
+        if plan.get("capability_gaps") and media_analysis_plan_requires_capabilities(plan):
             return _media_analysis_missing_capabilities_response(plan, action_label="metadata publish analysis")
 
         manifest = await execute_media_analysis_plan_async(
@@ -16268,7 +16269,11 @@ async def media_analysis(action: str, params: Optional[Dict[str, Any]] = None, c
             plan["setup_defaults_applied"] = p.get("_setup_defaults_applied")
         if warnings:
             plan["warnings"] = warnings
-        if plan.get("capability_gaps") and not bool(p.get("dry_run", True)):
+        if (
+            plan.get("capability_gaps")
+            and not bool(p.get("dry_run", True))
+            and media_analysis_plan_requires_capabilities(plan)
+        ):
             return _e2_wrap(_media_analysis_missing_capabilities_response(plan))
         if not bool(p.get("dry_run", True)):
             executed = await execute_media_analysis_plan_async(

package/src/utils/media_analysis.py

@@ -5117,6 +5117,37 @@ async def _maybe_run_vision_analysis(
     return _vision_analysis(record, motion, options, artifacts, capabilities)
 
 
+def _clip_is_reused(clip: Any) -> bool:
+    """A clip is satisfied by an existing report and runs no fresh analysis."""
+    return bool(
+        isinstance(clip, dict)
+        and clip.get("skip_execution")
+        and (clip.get("existing_report") or {}).get("path")
+    )
+
+
+def executing_clips(plan: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Clips in ``plan`` that still require fresh analysis (not pure reuse)."""
+    return [
+        clip
+        for clip in plan.get("clips", [])
+        if isinstance(clip, dict) and not _clip_is_reused(clip)
+    ]
+
+
+def plan_requires_capabilities(plan: Dict[str, Any]) -> bool:
+    """True when at least one clip needs fresh analysis.
+
+    ``build_plan`` records ``capability_gaps`` from the *requested* options
+    before the per-clip reuse decision runs. When every clip is satisfied by an
+    existing reusable report, execution only re-keys/imports those reports into
+    the current root and performs no fresh transcription/vision/ffprobe — so the
+    missing-capability gate must not fire. Callers gate with
+    ``plan.get("capability_gaps") and plan_requires_capabilities(plan)``.
+    """
+    return bool(executing_clips(plan))
+
+
 async def execute_plan_async(
     plan: Dict[str, Any],
     params: Optional[Dict[str, Any]] = None,
@@ -5155,7 +5186,8 @@ async def execute_plan_async(
                 for clip in blocked
             ],
         }
-    if plan.get("capability_gaps"):
+    fresh_clips = executing_clips(plan)
+    if plan.get("capability_gaps") and fresh_clips:
         return {
             "success": False,
             "error": "Cannot execute analysis with missing required capabilities",
@@ -5204,17 +5236,13 @@ async def execute_plan_async(
         and vision_uses_chat_context(options, caps)
         and not _coerce_bool(params.get("confirm_deep") or params.get("confirmDeep"), default=False)
     ):
-        executing = [
-            clip for clip in plan.get("clips", [])
-            if not (clip.get("skip_execution") and (clip.get("existing_report") or {}).get("path"))
-        ]
-        estimated_frames = sum(int(c.get("analysis_keyframe_budget") or 0) for c in executing)
+        estimated_frames = sum(int(c.get("analysis_keyframe_budget") or 0) for c in fresh_clips)
         return {
             "success": True,
             "status": "confirmation_required",
             "reason": "deep_depth_cost_estimate",
             "estimate": {
-                "clip_count": len(executing),
+                "clip_count": len(fresh_clips),
                 "estimated_frames": estimated_frames,
                 "estimated_vision_tokens": estimated_frames * AVG_VISION_TOKENS_PER_FRAME,
                 "tokens_per_frame_assumption": AVG_VISION_TOKENS_PER_FRAME,

package/src/utils/media_analysis_jobs.py

@@ -24,6 +24,7 @@ from src.utils.media_analysis import (
     detect_capabilities,
     execute_plan,
     normalize_path,
+    plan_requires_capabilities,
     resolve_output_root,
     stable_clip_directory,
     summarize_reports,
@@ -369,7 +370,7 @@ def create_batch_job(
     )
     if not plan.get("success"):
         return plan
-    if plan.get("capability_gaps"):
+    if plan.get("capability_gaps") and plan_requires_capabilities(plan):
         return {
             "success": False,
             "status": "missing_required_capabilities",