davinci-resolve-mcp 2.28.1 → 2.30.0

package/src/granular/media_pool_item.py

@@ -909,3 +909,112 @@ def clear_clip_mark_in_out(clip_id: str) -> Dict[str, Any]:
         return {"error": f"Clip {clip_id} not found"}
     result = clip.ClearMarkInOut()
     return {"success": bool(result)}
+
+
+_MARKER_COLORS = [
+    "Blue", "Cyan", "Green", "Yellow", "Red", "Pink", "Purple", "Fuchsia",
+    "Rose", "Lavender", "Sky", "Mint", "Lemon", "Sand", "Cocoa", "Cream",
+]
+
+
+@mcp.tool()
+def perform_clip_audio_classification(clip_id: str) -> Dict[str, Any]:
+    """Classify a clip's audio into categories and subcategories (Resolve 21+).
+
+    Args:
+        clip_id: Unique ID of the clip.
+    """
+    _, mp, err = _get_mp()
+    if err:
+        return err
+    clip = _find_clip_by_id(mp.GetRootFolder(), clip_id)
+    if not clip:
+        return {"error": f"Clip {clip_id} not found"}
+    if not hasattr(clip, "PerformAudioClassification"):
+        return {"error": "PerformAudioClassification requires DaVinci Resolve 21+"}
+    return {"success": bool(clip.PerformAudioClassification())}
+
+
+@mcp.tool()
+def clear_clip_audio_classification(clip_id: str) -> Dict[str, Any]:
+    """Clear a clip's audio classification (Resolve 21+).
+
+    Args:
+        clip_id: Unique ID of the clip.
+    """
+    _, mp, err = _get_mp()
+    if err:
+        return err
+    clip = _find_clip_by_id(mp.GetRootFolder(), clip_id)
+    if not clip:
+        return {"error": f"Clip {clip_id} not found"}
+    if not hasattr(clip, "ClearAudioClassification"):
+        return {"error": "ClearAudioClassification requires DaVinci Resolve 21+"}
+    return {"success": bool(clip.ClearAudioClassification())}
+
+
+@mcp.tool()
+def analyze_clip_for_intellisearch(clip_id: str, identify_faces: bool = False, is_better_mode: bool = False) -> Dict[str, Any]:
+    """Run IntelliSearch analysis on a clip (Resolve 21+, requires AI IntelliSearch Extra).
+
+    Args:
+        clip_id: Unique ID of the clip.
+        identify_faces: Whether to identify faces.
+        is_better_mode: Use Better mode (vs Faster).
+    """
+    _, mp, err = _get_mp()
+    if err:
+        return err
+    clip = _find_clip_by_id(mp.GetRootFolder(), clip_id)
+    if not clip:
+        return {"error": f"Clip {clip_id} not found"}
+    if not hasattr(clip, "AnalyzeForIntellisearch"):
+        return {"error": "AnalyzeForIntellisearch requires DaVinci Resolve 21+"}
+    return {"success": bool(clip.AnalyzeForIntellisearch(bool(identify_faces), bool(is_better_mode)))}
+
+
+@mcp.tool()
+def analyze_clip_for_slate(clip_id: str, marker_color: str = "Blue") -> Dict[str, Any]:
+    """Run Slate analysis on a clip (Resolve 21+, requires AI Slate ID Extra).
+
+    Args:
+        clip_id: Unique ID of the clip.
+        marker_color: Marker color for detected slates (Blue, Cyan, Green, Yellow, Red, Pink,
+            Purple, Fuchsia, Rose, Lavender, Sky, Mint, Lemon, Sand, Cocoa, Cream).
+    """
+    _, mp, err = _get_mp()
+    if err:
+        return err
+    clip = _find_clip_by_id(mp.GetRootFolder(), clip_id)
+    if not clip:
+        return {"error": f"Clip {clip_id} not found"}
+    if not hasattr(clip, "AnalyzeForSlate"):
+        return {"error": "AnalyzeForSlate requires DaVinci Resolve 21+"}
+    if marker_color not in _MARKER_COLORS:
+        return {"error": f"Invalid marker_color '{marker_color}'. Valid: {', '.join(_MARKER_COLORS)}"}
+    return {"success": bool(clip.AnalyzeForSlate(marker_color))}
+
+
+@mcp.tool()
+def remove_clip_motion_blur(clip_id: str, deblur_option: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """Render a motion-deblurred copy of a clip (Resolve 21+).
+
+    Creates a NEW media file; the source clip is not modified.
+
+    Args:
+        clip_id: Unique ID of the clip.
+        deblur_option: Settings dict (FileName, Format, Codec, EncodingProfile,
+            UseExtremeMode, UseMarkInMarkOut, RenderAtSourceRes, UseMoreGpuMemory).
+    """
+    _, mp, err = _get_mp()
+    if err:
+        return err
+    clip = _find_clip_by_id(mp.GetRootFolder(), clip_id)
+    if not clip:
+        return {"error": f"Clip {clip_id} not found"}
+    if not hasattr(clip, "RemoveMotionBlur"):
+        return {"error": "RemoveMotionBlur requires DaVinci Resolve 21+"}
+    new_clip = clip.RemoveMotionBlur(deblur_option or {})
+    if not new_clip:
+        return {"success": False}
+    return {"success": True, "new": new_clip.GetName(), "new_id": new_clip.GetUniqueId()}

package/src/granular/project.py

@@ -1592,3 +1592,59 @@ def load_cloud_project(project_name: str, project_media_path: str, sync_mode: st
     if project:
         return {"success": True, "project_name": project.GetName()}
     return {"success": False, "error": "Failed to load cloud project. Check cloud settings and connectivity."}
+
+
+@mcp.tool()
+def generate_speech(text_input: str, voice_model: str = "", timecode: str = "",
+                    add_to_timeline: bool = False, audio_track: Optional[int] = None,
+                    custom_voice_file: str = "", speed: Optional[int] = None,
+                    variation: Optional[int] = None, pitch: Optional[int] = None,
+                    generation_id: Optional[int] = None, filename: str = "") -> Dict[str, Any]:
+    """Generate AI text-to-speech audio and add it to the media pool (Resolve 21+).
+
+    Requires the AI Speech Generator Extra. Creates a NEW audio MediaPoolItem; if
+    add_to_timeline is True it is placed on the timeline at the given timecode.
+
+    Args:
+        text_input: Text to synthesize (required).
+        voice_model: Voice model name (e.g. "Female 1", "Male 1", "Custom Voice").
+        timecode: Timeline timecode to place the clip at when add_to_timeline is True.
+        add_to_timeline: Whether to add the generated clip to the timeline.
+        audio_track: Audio track index for timeline placement.
+        custom_voice_file: Full path to a custom voice file (for "Custom Voice").
+        speed: Speech speed.
+        variation: Voice variation.
+        pitch: Voice pitch.
+        generation_id: Generation ID.
+        filename: Output filename.
+    """
+    pm, current_project = get_current_project()
+    if not current_project:
+        return {"error": "No project currently open"}
+    if not hasattr(current_project, "GenerateSpeech"):
+        return {"error": "GenerateSpeech requires DaVinci Resolve 21+ and the AI Speech Generator Extra"}
+    if not text_input:
+        return {"error": "text_input is required"}
+    settings: Dict[str, Any] = {"TextInput": text_input}
+    if voice_model:
+        settings["VoiceModel"] = voice_model
+    if custom_voice_file:
+        settings["CustomVoiceFile"] = custom_voice_file
+    if speed is not None:
+        settings["Speed"] = speed
+    if variation is not None:
+        settings["Variation"] = variation
+    if pitch is not None:
+        settings["Pitch"] = pitch
+    if generation_id is not None:
+        settings["GenerationID"] = generation_id
+    if filename:
+        settings["Filename"] = filename
+    if add_to_timeline:
+        settings["AddToTimeline"] = True
+        if audio_track is not None:
+            settings["AudioTrack"] = audio_track
+    new_item = current_project.GenerateSpeech(settings, timecode or "")
+    if not new_item:
+        return {"success": False, "error": "GenerateSpeech returned no media item"}
+    return {"success": True, "new": new_item.GetName(), "new_id": new_item.GetUniqueId()}

package/src/granular/resolve_control.py

@@ -293,6 +293,23 @@ def delete_layout_preset_tool(preset_name: str) -> Dict[str, Any]:
     return {"success": bool(result), "preset_name": preset_name}
 
 
+@mcp.tool()
+def disable_background_tasks_for_current_session() -> Dict[str, Any]:
+    """Disable all background tasks for the current Resolve session (Resolve 21+).
+
+    Useful before heavy scripted operations so Resolve does not run background
+    work that competes for resources. Resets when Resolve restarts.
+    """
+    resolve = get_resolve()
+    if resolve is None:
+        return {"error": "Not connected to DaVinci Resolve"}
+    missing = _requires_method(resolve, "DisableBackgroundTasksForCurrentResolveSession", "21.0")
+    if missing:
+        return missing
+    resolve.DisableBackgroundTasksForCurrentResolveSession()
+    return {"success": True}
+
+
 @mcp.resource("resolve://app/state")
 def get_app_state_endpoint() -> Dict[str, Any]:
     """Get DaVinci Resolve application state information."""

package/src/resolve_mcp_server.py

@@ -34,7 +34,7 @@ from src.utils.update_check import start_background_update_check
 if __name__ == "__main__":
     try:
         start_background_update_check(VERSION, project_dir, logger)
-        logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION} (329 granular tools)")
+        logger.info(f"Starting DaVinci Resolve MCP Server v{VERSION} (341 granular tools)")
         run_fastmcp_stdio(mcp)
     except KeyboardInterrupt:
         logger.info("Server shutdown requested")

package/src/server.py

@@ -8,10 +8,10 @@ Each tool groups related operations via an 'action' parameter.
 
 Usage:
     python src/server.py              # Start the MCP server
-    python src/server.py --full       # Start the 329-tool granular server instead
+    python src/server.py --full       # Start the 341-tool granular server instead
 """
 
-VERSION = "2.28.1"
+VERSION = "2.30.0"
 
 import base64
 import os
@@ -639,6 +639,42 @@ def _destructive_versioning_provider() -> Optional[Tuple[Any, Any, str, Optional
 _destructive_hook.register_project_root_provider(_destructive_versioning_provider)
 
 
+# ─── Resolve 21 AI-ops ledger plumbing ────────────────────────────────────────
+
+import uuid as _ledger_uuid
+from src.utils import resolve_ai_ledger as _resolve_ai_ledger
+
+# One id per server process so the ledger / dashboard can scope "this session".
+_AI_LEDGER_SESSION_ID = _ledger_uuid.uuid4().hex
+
+
+def _ai_ledger_root() -> Optional[str]:
+    """Best-effort project_root for the AI-ops ledger. None disables recording."""
+    try:
+        provider = _destructive_versioning_provider()
+        return provider[2] if provider else None
+    except Exception:
+        return None
+
+
+def _clip_file_size(item: Any) -> Tuple[Optional[str], Optional[int]]:
+    """(file_path, size_bytes) for a MediaPoolItem, or (path|None, None)."""
+    try:
+        path = item.GetClipProperty("File Path")
+        if isinstance(path, str) and path and os.path.exists(path):
+            return path, os.path.getsize(path)
+        return (path if isinstance(path, str) and path else None), None
+    except Exception:
+        return None, None
+
+
+def _ai_ledger_timed(op: str, *, clip_id: Optional[str] = None):
+    """Ledger context manager bound to the current project_root + session."""
+    return _resolve_ai_ledger.timed(
+        _ai_ledger_root(), op, clip_id=clip_id, session_id=_AI_LEDGER_SESSION_ID
+    )
+
+
 def _destructive_preference_provider(key: str) -> Any:
     """Reader for C6 preferences out of the existing media-analysis prefs file."""
     try:
@@ -658,6 +694,12 @@ _TOKEN_GATED_DESTRUCTIVE_ACTIONS = frozenset({
     ("timeline", "delete_track"),
     ("graph", "apply_grade_from_drx"),
     ("graph", "reset_all_grades"),
+    # 21.0 AI ops that render/generate NEW media files (additive, but expensive
+    # and irreversible without manual cleanup) — gated so they never run by
+    # surprise. They never modify source media.
+    ("folder", "remove_motion_blur"),
+    ("media_pool_item", "remove_motion_blur"),
+    ("project_settings", "generate_speech"),
 })
 
 
@@ -5404,6 +5446,11 @@ def _transcription_capabilities(mp, p: Dict[str, Any]):
                 "summary": _media_pool_item_summary(clip),
                 "transcribe_audio": _has_method(clip, "TranscribeAudio"),
                 "clear_transcription": _has_method(clip, "ClearTranscription"),
+                "perform_audio_classification": _has_method(clip, "PerformAudioClassification"),
+                "clear_audio_classification": _has_method(clip, "ClearAudioClassification"),
+                "analyze_for_intellisearch": _has_method(clip, "AnalyzeForIntellisearch"),
+                "analyze_for_slate": _has_method(clip, "AnalyzeForSlate"),
+                "remove_motion_blur": _has_method(clip, "RemoveMotionBlur"),
             }
             for clip in clips
         ],
@@ -5411,10 +5458,16 @@ def _transcription_capabilities(mp, p: Dict[str, Any]):
             "name": current_folder.GetName() if current_folder else None,
             "transcribe_audio": _has_method(current_folder, "TranscribeAudio") if current_folder else False,
             "clear_transcription": _has_method(current_folder, "ClearTranscription") if current_folder else False,
+            "perform_audio_classification": _has_method(current_folder, "PerformAudioClassification") if current_folder else False,
+            "clear_audio_classification": _has_method(current_folder, "ClearAudioClassification") if current_folder else False,
+            "analyze_for_intellisearch": _has_method(current_folder, "AnalyzeForIntellisearch") if current_folder else False,
+            "analyze_for_slate": _has_method(current_folder, "AnalyzeForSlate") if current_folder else False,
+            "remove_motion_blur": _has_method(current_folder, "RemoveMotionBlur") if current_folder else False,
         },
         "notes": [
-            "This action reports capability only; use media_pool_item/folder transcription actions to mutate disposable or approved clips.",
-            "Transcription may require Resolve Studio AI components and can run asynchronously.",
+            "This action reports capability only; use media_pool_item/folder actions to mutate disposable or approved clips.",
+            "Transcription/audio-classification may require Resolve Studio AI components and can run asynchronously.",
+            "analyze_for_intellisearch requires the 'AI IntelliSearch' Extra; analyze_for_slate requires 'AI Slate ID'; remove_motion_blur creates new media and is confirm-gated (Resolve 21+).",
         ],
     }
 
@@ -10336,6 +10389,7 @@ def resolve_control(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
       quit() -> {success}
       get_fairlight_presets() -> {presets}
       set_high_priority() -> {success}
+      disable_background_tasks_for_current_session() -> {success}  — Resolve 21+
       open_control_panel(port?, host?, open_browser?) -> {success, url, pid, port, status}
         — Launches the analysis control panel (src/analysis_dashboard.py) as a background process.
           Idempotent: returns the existing URL if already running.
@@ -10429,7 +10483,13 @@ def resolve_control(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
         return {"presets": _ser(r.GetFairlightPresets())}
     elif action == "set_high_priority":
         return {"success": bool(r.SetHighPriority())}
-    return _unknown(action, ["launch","get_version","mcp_update_status","set_mcp_update_policy","ignore_mcp_update","snooze_mcp_update","clear_mcp_update_preferences","get_page","open_page","get_keyframe_mode","set_keyframe_mode","quit","get_fairlight_presets","set_high_priority","open_control_panel","control_panel_status","close_control_panel","save_state","restore_state"])
+    elif action == "disable_background_tasks_for_current_session":
+        missing = _requires_method(r, "DisableBackgroundTasksForCurrentResolveSession", "21.0")
+        if missing:
+            return missing
+        r.DisableBackgroundTasksForCurrentResolveSession()
+        return _ok()
+    return _unknown(action, ["launch","get_version","mcp_update_status","set_mcp_update_policy","ignore_mcp_update","snooze_mcp_update","clear_mcp_update_preferences","get_page","open_page","get_keyframe_mode","set_keyframe_mode","quit","get_fairlight_presets","set_high_priority","disable_background_tasks_for_current_session","open_control_panel","control_panel_status","close_control_panel","save_state","restore_state"])
 
 
 # ─── V2 C4: Per-field corrections with provenance + changelog ────────────────
@@ -12327,6 +12387,7 @@ def project_settings(action: str, params: Optional[Dict[str, Any]] = None) -> Di
       add_color_group(name) -> {success, name}
       delete_color_group(name) -> {success}
       apply_fairlight_preset(preset_name) -> {success}
+      generate_speech(speech_generation_settings, timecode?) -> {success, new, new_id}  — Resolve 21+, AI Speech Generator; creates new audio media (confirm-gated)
     """
     p = params or {}
     _, proj, err = _check()
@@ -12376,7 +12437,44 @@ def project_settings(action: str, params: Optional[Dict[str, Any]] = None) -> Di
         if missing:
             return missing
         return {"success": bool(proj.ApplyFairlightPresetToCurrentTimeline(p["preset_name"]))}
-    return _unknown(action, ["get_name","set_name","get_setting","set_setting","get_unique_id","get_presets","set_preset","refresh_luts","get_gallery","export_frame_as_still","load_burnin_preset","insert_audio","get_color_groups","add_color_group","delete_color_group","apply_fairlight_preset"])
+    elif action == "generate_speech":
+        missing = _requires_method(proj, "GenerateSpeech", "21.0")
+        if missing:
+            return missing
+        settings = _first_param(p, "speech_generation_settings", "speechGenerationSettings", "settings", default=None) or {}
+        if not isinstance(settings, dict) or not settings.get("TextInput"):
+            return _err("generate_speech requires speech_generation_settings with a 'TextInput' string. "
+                        "Optional keys: VoiceModel, CustomVoiceFile, Speed, Variation, Pitch, GenerationID, Filename, AddToTimeline, AudioTrack.")
+        timecode = _first_param(p, "timecode", default="") or ""
+        if "confirm_token" not in p and "confirmToken" not in p and _confirm_token_required():
+            return _issue_confirm_token(
+                action="project_settings.generate_speech",
+                params=p,
+                preview={
+                    "operation": "project_settings.generate_speech",
+                    "warning": "Generates a NEW AI text-to-speech audio item"
+                               + (" and adds it to the timeline." if settings.get("AddToTimeline") else "."),
+                    "text_input": settings.get("TextInput"),
+                    "voice_model": settings.get("VoiceModel"),
+                    "add_to_timeline": bool(settings.get("AddToTimeline")),
+                    "timecode": timecode,
+                },
+            )
+        blocked = _consume_confirm_token(action="project_settings.generate_speech", params=p)
+        if blocked:
+            return blocked
+        with _ai_ledger_timed("generate_speech") as _rec:
+            new_item = proj.GenerateSpeech(settings, timecode)
+            _rec.success = bool(new_item)
+            if new_item:
+                path, nbytes = _clip_file_size(new_item)
+                _rec.output_path = path
+                _rec.output_bytes = nbytes
+        if not new_item:
+            return {"success": False}
+        return {"success": True, "new": new_item.GetName(), "new_id": new_item.GetUniqueId(),
+                "output_path": _rec.output_path, "output_bytes": _rec.output_bytes}
+    return _unknown(action, ["get_name","set_name","get_setting","set_setting","get_unique_id","get_presets","set_preset","refresh_luts","get_gallery","export_frame_as_still","load_burnin_preset","insert_audio","get_color_groups","add_color_group","delete_color_group","apply_fairlight_preset","generate_speech"])
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -13316,8 +13414,13 @@ def folder(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
       is_stale(path?) -> {stale}
       get_unique_id(path?) -> {id}
       export(path?, export_path) -> {success}
-      transcribe_audio(path?) -> {success}
+      transcribe_audio(path?, use_speaker_detection?) -> {success}  — use_speaker_detection is Resolve 21+
       clear_transcription(path?) -> {success}
+      perform_audio_classification(path?) -> {success}  — Resolve 21+
+      clear_audio_classification(path?) -> {success}  — Resolve 21+
+      analyze_for_intellisearch(path?, identify_faces?, is_better_mode?) -> {success}  — Resolve 21+, AI IntelliSearch Extra
+      analyze_for_slate(path?, marker_color?) -> {success}  — Resolve 21+, AI Slate ID Extra
+      remove_motion_blur(path?, deblur_option?) -> {success, created}  — Resolve 21+; renders NEW media (confirm-gated)
     """
     p = params or {}
     _, _, mp, err = _get_mp()
@@ -13344,10 +13447,89 @@ def folder(action: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, An
     elif action == "export":
         return {"success": bool(f.Export(p["export_path"]))}
     elif action == "transcribe_audio":
-        return {"success": bool(f.TranscribeAudio())}
+        usd = _first_param(p, "use_speaker_detection", "useSpeakerDetection")
+        if usd is None:
+            return {"success": bool(f.TranscribeAudio())}
+        return {"success": bool(f.TranscribeAudio(bool(usd)))}
     elif action == "clear_transcription":
         return {"success": bool(f.ClearTranscription())}
-    return _unknown(action, ["get_clips","get_name","get_subfolders","is_stale","get_unique_id","export","transcribe_audio","clear_transcription"])
+    elif action == "perform_audio_classification":
+        missing = _requires_method(f, "PerformAudioClassification", "21.0")
+        if missing:
+            return missing
+        with _ai_ledger_timed("perform_audio_classification") as _rec:
+            ok = bool(f.PerformAudioClassification())
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "clear_audio_classification":
+        missing = _requires_method(f, "ClearAudioClassification", "21.0")
+        if missing:
+            return missing
+        with _ai_ledger_timed("clear_audio_classification") as _rec:
+            ok = bool(f.ClearAudioClassification())
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "analyze_for_intellisearch":
+        missing = _requires_method(f, "AnalyzeForIntellisearch", "21.0")
+        if missing:
+            return missing
+        identify_faces = bool(_first_param(p, "identify_faces", "identifyFaces", default=False))
+        is_better_mode = bool(_first_param(p, "is_better_mode", "isBetterMode", default=False))
+        with _ai_ledger_timed("analyze_for_intellisearch") as _rec:
+            ok = bool(f.AnalyzeForIntellisearch(identify_faces, is_better_mode))
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "analyze_for_slate":
+        missing = _requires_method(f, "AnalyzeForSlate", "21.0")
+        if missing:
+            return missing
+        marker_color = _first_param(p, "marker_color", "markerColor", default="Blue")
+        if marker_color not in _MARKER_COLORS:
+            return _err(f"Invalid marker_color {marker_color!r}. Valid colors: {', '.join(_MARKER_COLORS)}")
+        with _ai_ledger_timed("analyze_for_slate") as _rec:
+            ok = bool(f.AnalyzeForSlate(marker_color))
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "remove_motion_blur":
+        missing = _requires_method(f, "RemoveMotionBlur", "21.0")
+        if missing:
+            return missing
+        deblur = _first_param(p, "deblur_option", "deblurOption", default=None) or {}
+        if "confirm_token" not in p and "confirmToken" not in p and _confirm_token_required():
+            return _issue_confirm_token(
+                action="folder.remove_motion_blur",
+                params=p,
+                preview={
+                    "operation": "folder.remove_motion_blur",
+                    "warning": "Renders NEW deblurred media files for clips in the folder; source media is not modified.",
+                    "folder": f.GetName(),
+                    "deblur_option": deblur,
+                },
+            )
+        blocked = _consume_confirm_token(action="folder.remove_motion_blur", params=p)
+        if blocked:
+            return blocked
+        with _ai_ledger_timed("remove_motion_blur") as _rec:
+            result = f.RemoveMotionBlur(deblur)
+            _rec.success = bool(result)
+            created = []
+            total_bytes = 0
+            for pair in (result or []):
+                try:
+                    orig, new = pair
+                    path, nbytes = _clip_file_size(new)
+                    if nbytes:
+                        total_bytes += nbytes
+                    created.append({"original": orig.GetName(), "new": new.GetName(),
+                                    "new_id": new.GetUniqueId(), "output_path": path, "output_bytes": nbytes})
+                except Exception:
+                    continue
+            # Folder deblur creates many files; record the first path + summed bytes.
+            if created:
+                _rec.output_path = created[0].get("output_path")
+                _rec.output_bytes = total_bytes or None
+        return {"success": bool(result), "created": created}
+    return _unknown(action, ["get_clips","get_name","get_subfolders","is_stale","get_unique_id","export","transcribe_audio","clear_transcription","perform_audio_classification","clear_audio_classification","analyze_for_intellisearch","analyze_for_slate","remove_motion_blur"])
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -13378,8 +13560,13 @@ def media_pool_item(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
       monitor_growing_file(clip_id) -> {success}
       replace_clip_preserve_sub_clip(clip_id, path) -> {success}
       get_unique_id(clip_id) -> {id}
-      transcribe_audio(clip_id) -> {success}
+      transcribe_audio(clip_id, use_speaker_detection?) -> {success}  — use_speaker_detection is Resolve 21+
       clear_transcription(clip_id) -> {success}
+      perform_audio_classification(clip_id) -> {success}  — Resolve 21+
+      clear_audio_classification(clip_id) -> {success}  — Resolve 21+
+      analyze_for_intellisearch(clip_id, identify_faces?, is_better_mode?) -> {success}  — Resolve 21+, AI IntelliSearch Extra
+      analyze_for_slate(clip_id, marker_color?) -> {success}  — Resolve 21+, AI Slate ID Extra
+      remove_motion_blur(clip_id, deblur_option?) -> {success, new, new_id}  — Resolve 21+; renders NEW media (confirm-gated)
       get_audio_mapping(clip_id) -> {mapping}
       get_mark_in_out(clip_id) -> {mark}
       set_mark_in_out(clip_id, mark_in, mark_out, type?) -> {success}
@@ -13570,9 +13757,79 @@ def media_pool_item(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
     elif action == "get_unique_id":
         return {"id": clip.GetUniqueId()}
     elif action == "transcribe_audio":
-        return {"success": bool(clip.TranscribeAudio())}
+        usd = _first_param(p, "use_speaker_detection", "useSpeakerDetection")
+        if usd is None:
+            return {"success": bool(clip.TranscribeAudio())}
+        return {"success": bool(clip.TranscribeAudio(bool(usd)))}
     elif action == "clear_transcription":
         return {"success": bool(clip.ClearTranscription())}
+    elif action == "perform_audio_classification":
+        missing = _requires_method(clip, "PerformAudioClassification", "21.0")
+        if missing:
+            return missing
+        with _ai_ledger_timed("perform_audio_classification", clip_id=p.get("clip_id")) as _rec:
+            ok = bool(clip.PerformAudioClassification())
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "clear_audio_classification":
+        missing = _requires_method(clip, "ClearAudioClassification", "21.0")
+        if missing:
+            return missing
+        with _ai_ledger_timed("clear_audio_classification", clip_id=p.get("clip_id")) as _rec:
+            ok = bool(clip.ClearAudioClassification())
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "analyze_for_intellisearch":
+        missing = _requires_method(clip, "AnalyzeForIntellisearch", "21.0")
+        if missing:
+            return missing
+        identify_faces = bool(_first_param(p, "identify_faces", "identifyFaces", default=False))
+        is_better_mode = bool(_first_param(p, "is_better_mode", "isBetterMode", default=False))
+        with _ai_ledger_timed("analyze_for_intellisearch", clip_id=p.get("clip_id")) as _rec:
+            ok = bool(clip.AnalyzeForIntellisearch(identify_faces, is_better_mode))
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "analyze_for_slate":
+        missing = _requires_method(clip, "AnalyzeForSlate", "21.0")
+        if missing:
+            return missing
+        marker_color = _first_param(p, "marker_color", "markerColor", default="Blue")
+        if marker_color not in _MARKER_COLORS:
+            return _err(f"Invalid marker_color {marker_color!r}. Valid colors: {', '.join(_MARKER_COLORS)}")
+        with _ai_ledger_timed("analyze_for_slate", clip_id=p.get("clip_id")) as _rec:
+            ok = bool(clip.AnalyzeForSlate(marker_color))
+            _rec.success = ok
+        return {"success": ok}
+    elif action == "remove_motion_blur":
+        missing = _requires_method(clip, "RemoveMotionBlur", "21.0")
+        if missing:
+            return missing
+        deblur = _first_param(p, "deblur_option", "deblurOption", default=None) or {}
+        if "confirm_token" not in p and "confirmToken" not in p and _confirm_token_required():
+            return _issue_confirm_token(
+                action="media_pool_item.remove_motion_blur",
+                params=p,
+                preview={
+                    "operation": "media_pool_item.remove_motion_blur",
+                    "warning": "Renders a NEW deblurred media file; the source clip is not modified.",
+                    "clip": clip.GetName(),
+                    "deblur_option": deblur,
+                },
+            )
+        blocked = _consume_confirm_token(action="media_pool_item.remove_motion_blur", params=p)
+        if blocked:
+            return blocked
+        with _ai_ledger_timed("remove_motion_blur", clip_id=p.get("clip_id")) as _rec:
+            new_clip = clip.RemoveMotionBlur(deblur)
+            _rec.success = bool(new_clip)
+            if new_clip:
+                path, nbytes = _clip_file_size(new_clip)
+                _rec.output_path = path
+                _rec.output_bytes = nbytes
+        if not new_clip:
+            return {"success": False}
+        return {"success": True, "new": new_clip.GetName(), "new_id": new_clip.GetUniqueId(),
+                "output_path": _rec.output_path, "output_bytes": _rec.output_bytes}
     elif action == "get_audio_mapping":
         return {"mapping": clip.GetAudioMapping()}
     elif action == "get_mark_in_out":
@@ -13581,7 +13838,7 @@ def media_pool_item(action: str, params: Optional[Dict[str, Any]] = None) -> Dic
         return {"success": bool(clip.SetMarkInOut(p["mark_in"], p["mark_out"], p.get("type", "all")))}
     elif action == "clear_mark_in_out":
         return {"success": bool(clip.ClearMarkInOut(p.get("type", "all")))}
-    return _unknown(action, ["get_name","get_metadata","set_metadata","get_third_party_metadata","set_third_party_metadata","get_media_id","get_clip_property","set_clip_property","get_clip_color","set_clip_color","clear_clip_color","link_proxy","unlink_proxy","replace_clip","set_name","link_full_resolution_media","monitor_growing_file","replace_clip_preserve_sub_clip","get_unique_id","transcribe_audio","clear_transcription","get_audio_mapping","get_mark_in_out","set_mark_in_out","clear_mark_in_out","open_in_viewer"])
+    return _unknown(action, ["get_name","get_metadata","set_metadata","get_third_party_metadata","set_third_party_metadata","get_media_id","get_clip_property","set_clip_property","get_clip_color","set_clip_color","clear_clip_color","link_proxy","unlink_proxy","replace_clip","set_name","link_full_resolution_media","monitor_growing_file","replace_clip_preserve_sub_clip","get_unique_id","transcribe_audio","clear_transcription","perform_audio_classification","clear_audio_classification","analyze_for_intellisearch","analyze_for_slate","remove_motion_blur","get_audio_mapping","get_mark_in_out","set_mark_in_out","clear_mark_in_out","open_in_viewer"])
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -13721,6 +13978,7 @@ async def media_analysis(action: str, params: Optional[Dict[str, Any]] = None, c
       get_caps(clip_id?, job_id?) -> {preset, caps, presets_available, usage?} — effective caps + usage rollup (vision tokens consumed per scope, percent of budget).
       set_caps_preset(preset, overrides?) -> {success, preset, overrides} — preset is minimal | standard | generous | unlimited. Overrides is a dict of {field: int|"unlimited"} that wins over the preset.
       get_usage(scope?, scope_key?, clip_id?, job_id?) -> {scope, usage} — raw usage rollup for one scope (clip | job | day).
+      get_resolve_ai_usage(session_only?, op?, limit?) -> {summary, recent} — ledger of Resolve 21 local AI ops (audio classification, IntelliSearch, slate, motion-deblur, speech). Tracks invocations, wall-clock, and files/bytes created by the two media-creating ops. Separate from get_caps/get_usage (those meter Claude-side tokens; these ops don't spend them).
       resolve_output_root(analysis_root?, source_paths?) -> {project_root}
       plan(target, depth?, analysis_root?, transcription?, vision?, dry_run?) -> {clips, artifacts}
       analyze_file(path|file_path, dry_run?, session_only?, persist?) -> {clips, manifest}
@@ -13873,6 +14131,27 @@ async def media_analysis(action: str, params: Optional[Dict[str, Any]] = None, c
         except Exception as exc:
             out["usage_error"] = f"{type(exc).__name__}: {exc}"
         return out
+    if action == "get_resolve_ai_usage":
+        # Ledger of Resolve-local 21.0 AI ops (audio classification, IntelliSearch,
+        # slate, motion-deblur, speech generation). Distinct from get_caps/get_usage,
+        # which meter Claude-side analysis tokens — these ops don't spend those.
+        try:
+            vctx = _destructive_versioning_provider()
+            if vctx is None:
+                return _err("No project context — open a Resolve project first")
+            _r, _proj, project_root, _name = vctx
+            session_only = bool(p.get("session_only", False))
+            session_id = _AI_LEDGER_SESSION_ID if session_only else None
+            limit = int(p.get("limit", 50))
+            return {
+                "success": True,
+                "session_id": _AI_LEDGER_SESSION_ID,
+                "scope": "session" if session_only else "project",
+                "summary": _resolve_ai_ledger.get_summary(project_root=project_root, session_id=session_id),
+                "recent": _resolve_ai_ledger.get_usage(project_root=project_root, session_id=session_id, op=p.get("op"), limit=limit),
+            }
+        except Exception as exc:
+            return _err(f"{type(exc).__name__}: {exc}")
     if action == "set_caps_preset":
         preset = (p.get("preset") or "").strip().lower()
         from src.utils import analysis_caps as _ac
@@ -20106,9 +20385,9 @@ def _resource_install_guidance() -> Dict[str, Any]:
 if __name__ == "__main__":
     start_background_update_check(VERSION, project_dir, logger, env=_setup_update_env())
 
-    # Support --full flag to run the 329-tool granular server instead
+    # Support --full flag to run the 341-tool granular server instead
     if "--full" in sys.argv:
-        logger.info("Starting full 329-tool granular server...")
+        logger.info("Starting full 341-tool granular server...")
         sys.argv = [arg for arg in sys.argv if arg != "--full"]
         from src.granular import mcp as granular_mcp