@hybridlabor-api/aos 4.3.0 → 4.4.1

package/mcps/davinci-resolve-mcp/tests/test_live_api.py

@@ -1,315 +0,0 @@
-#!/usr/bin/env python3
-"""
-Live API test harness - tests actual DaVinci Resolve API calls.
-Run with: python3 tests/test_live_api.py
-Requires DaVinci Resolve to be running.
-"""
-
-import sys
-import json
-import traceback
-
-sys.path.insert(0, '/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules')
-
-import DaVinciResolveScript as dvr
-
-def test_api():
-    results = {}
-
-    # Connect
-    resolve = dvr.scriptapp('Resolve')
-    if not resolve:
-        print("FATAL: Cannot connect to Resolve")
-        return
-
-    print(f"Connected to {resolve.GetProductName()} {resolve.GetVersionString()}")
-    print("=" * 60)
-
-    # ===== RESOLVE OBJECT =====
-    print("\n--- Resolve Object ---")
-
-    tests = {
-        "Resolve.GetProductName": lambda: resolve.GetProductName(),
-        "Resolve.GetVersion": lambda: resolve.GetVersion(),
-        "Resolve.GetVersionString": lambda: resolve.GetVersionString(),
-        "Resolve.GetCurrentPage": lambda: resolve.GetCurrentPage(),
-        "Resolve.GetMediaStorage": lambda: resolve.GetMediaStorage() is not None,
-        "Resolve.GetProjectManager": lambda: resolve.GetProjectManager() is not None,
-        "Resolve.GetKeyframeMode": lambda: resolve.GetKeyframeMode(),
-        "Resolve.Fusion": lambda: resolve.Fusion(),
-    }
-
-    for name, fn in tests.items():
-        try:
-            result = fn()
-            results[name] = {"status": "OK", "value": str(result)[:100]}
-            print(f"  ✓ {name} = {str(result)[:80]}")
-        except Exception as e:
-            results[name] = {"status": "FAIL", "error": str(e)}
-            print(f"  ✗ {name} ERROR: {e}")
-
-    # ===== PROJECT MANAGER =====
-    print("\n--- ProjectManager Object ---")
-    pm = resolve.GetProjectManager()
-
-    pm_tests = {
-        "PM.GetCurrentProject": lambda: pm.GetCurrentProject() is not None,
-        "PM.GetProjectListInCurrentFolder": lambda: pm.GetProjectListInCurrentFolder(),
-        "PM.GetFolderListInCurrentFolder": lambda: pm.GetFolderListInCurrentFolder(),
-        "PM.GetCurrentFolder": lambda: pm.GetCurrentFolder(),
-        "PM.GetCurrentDatabase": lambda: pm.GetCurrentDatabase(),
-        "PM.GetDatabaseList": lambda: pm.GetDatabaseList(),
-    }
-
-    for name, fn in pm_tests.items():
-        try:
-            result = fn()
-            results[name] = {"status": "OK", "value": str(result)[:100]}
-            print(f"  ✓ {name} = {str(result)[:80]}")
-        except Exception as e:
-            results[name] = {"status": "FAIL", "error": str(e)}
-            print(f"  ✗ {name} ERROR: {e}")
-
-    # ===== PROJECT =====
-    print("\n--- Project Object ---")
-    project = pm.GetCurrentProject()
-
-    proj_tests = {
-        "Project.GetName": lambda: project.GetName(),
-        "Project.GetMediaPool": lambda: project.GetMediaPool() is not None,
-        "Project.GetTimelineCount": lambda: project.GetTimelineCount(),
-        "Project.GetSetting('')": lambda: project.GetSetting(''),
-        "Project.GetRenderFormats": lambda: project.GetRenderFormats(),
-        "Project.GetRenderCodecs": lambda: project.GetRenderCodecs('mp4'),
-        "Project.GetCurrentRenderFormatAndCodec": lambda: project.GetCurrentRenderFormatAndCodec(),
-        "Project.GetCurrentRenderMode": lambda: project.GetCurrentRenderMode(),
-        "Project.GetRenderPresetList": lambda: project.GetRenderPresetList(),
-        "Project.GetRenderJobList": lambda: project.GetRenderJobList(),
-        "Project.IsRenderingInProgress": lambda: project.IsRenderingInProgress(),
-        "Project.GetGallery": lambda: project.GetGallery() is not None,
-        "Project.GetUniqueId": lambda: project.GetUniqueId(),
-        "Project.GetPresetList": lambda: project.GetPresetList(),
-        "Project.GetColorGroupsList": lambda: project.GetColorGroupsList(),
-        "Project.RefreshLUTList": lambda: project.RefreshLUTList(),
-        "Project.GetQuickExportRenderPresets": lambda: project.GetQuickExportRenderPresets(),
-        "Project.GetRenderResolutions": lambda: project.GetRenderResolutions('mp4', 'H.264'),
-    }
-
-    for name, fn in proj_tests.items():
-        try:
-            result = fn()
-            val_str = str(result)[:100]
-            results[name] = {"status": "OK", "value": val_str}
-            print(f"  ✓ {name} = {val_str[:80]}")
-        except Exception as e:
-            results[name] = {"status": "FAIL", "error": str(e)}
-            print(f"  ✗ {name} ERROR: {e}")
-
-    # ===== MEDIA STORAGE =====
-    print("\n--- MediaStorage Object ---")
-    ms = resolve.GetMediaStorage()
-
-    ms_tests = {
-        "MS.GetMountedVolumeList": lambda: ms.GetMountedVolumeList(),
-        "MS.GetSubFolderList": lambda: ms.GetSubFolderList(ms.GetMountedVolumeList()[0]) if ms.GetMountedVolumeList() else "no volumes",
-        "MS.GetFileList": lambda: ms.GetFileList(ms.GetMountedVolumeList()[0])[:5] if ms.GetMountedVolumeList() else "no volumes",
-    }
-
-    for name, fn in ms_tests.items():
-        try:
-            result = fn()
-            val_str = str(result)[:100]
-            results[name] = {"status": "OK", "value": val_str}
-            print(f"  ✓ {name} = {val_str[:80]}")
-        except Exception as e:
-            results[name] = {"status": "FAIL", "error": str(e)}
-            print(f"  ✗ {name} ERROR: {e}")
-
-    # ===== MEDIA POOL =====
-    print("\n--- MediaPool Object ---")
-    mp = project.GetMediaPool()
-
-    mp_tests = {
-        "MP.GetRootFolder": lambda: mp.GetRootFolder() is not None,
-        "MP.GetCurrentFolder": lambda: mp.GetCurrentFolder() is not None,
-        "MP.GetUniqueId": lambda: mp.GetUniqueId(),
-        "MP.GetSelectedClips": lambda: mp.GetSelectedClips(),
-    }
-
-    for name, fn in mp_tests.items():
-        try:
-            result = fn()
-            val_str = str(result)[:100]
-            results[name] = {"status": "OK", "value": val_str}
-            print(f"  ✓ {name} = {val_str[:80]}")
-        except Exception as e:
-            results[name] = {"status": "FAIL", "error": str(e)}
-            print(f"  ✗ {name} ERROR: {e}")
-
-    # ===== FOLDER =====
-    print("\n--- Folder Object ---")
-    root = mp.GetRootFolder()
-
-    folder_tests = {
-        "Folder.GetName": lambda: root.GetName(),
-        "Folder.GetClipList": lambda: root.GetClipList(),
-        "Folder.GetSubFolderList": lambda: root.GetSubFolderList(),
-        "Folder.GetIsFolderStale": lambda: root.GetIsFolderStale(),
-        "Folder.GetUniqueId": lambda: root.GetUniqueId(),
-    }
-
-    for name, fn in folder_tests.items():
-        try:
-            result = fn()
-            val_str = str(result)[:100]
-            results[name] = {"status": "OK", "value": val_str}
-            print(f"  ✓ {name} = {val_str[:80]}")
-        except Exception as e:
-            results[name] = {"status": "FAIL", "error": str(e)}
-            print(f"  ✗ {name} ERROR: {e}")
-
-    # ===== GALLERY =====
-    print("\n--- Gallery Object ---")
-    gallery = project.GetGallery()
-
-    if gallery:
-        gallery_tests = {
-            "Gallery.GetAlbumName": lambda: gallery.GetAlbumName(),
-            "Gallery.GetCurrentStillAlbum": lambda: gallery.GetCurrentStillAlbum() is not None,
-            "Gallery.GetGalleryStillAlbums": lambda: gallery.GetGalleryStillAlbums(),
-            "Gallery.GetGalleryPowerGradeAlbums": lambda: gallery.GetGalleryPowerGradeAlbums(),
-        }
-
-        for name, fn in gallery_tests.items():
-            try:
-                result = fn()
-                val_str = str(result)[:100]
-                results[name] = {"status": "OK", "value": val_str}
-                print(f"  ✓ {name} = {val_str[:80]}")
-            except Exception as e:
-                results[name] = {"status": "FAIL", "error": str(e)}
-                print(f"  ✗ {name} ERROR: {e}")
-
-        # ===== GALLERY STILL ALBUM =====
-        print("\n--- GalleryStillAlbum Object ---")
-        album = gallery.GetCurrentStillAlbum()
-        if album:
-            album_tests = {
-                "GSA.GetStills": lambda: album.GetStills(),
-                "GSA.GetLabel": lambda: album.GetLabel(album.GetStills()[0]) if album.GetStills() else "no stills",
-            }
-            for name, fn in album_tests.items():
-                try:
-                    result = fn()
-                    val_str = str(result)[:100]
-                    results[name] = {"status": "OK", "value": val_str}
-                    print(f"  ✓ {name} = {val_str[:80]}")
-                except Exception as e:
-                    results[name] = {"status": "FAIL", "error": str(e)}
-                    print(f"  ✗ {name} ERROR: {e}")
-
-    # ===== TIMELINE (if any) =====
-    if project.GetTimelineCount() > 0:
-        print("\n--- Timeline Object ---")
-        tl = project.GetCurrentTimeline()
-        if tl:
-            tl_tests = {
-                "TL.GetName": lambda: tl.GetName(),
-                "TL.GetStartFrame": lambda: tl.GetStartFrame(),
-                "TL.GetEndFrame": lambda: tl.GetEndFrame(),
-                "TL.GetTrackCount('video')": lambda: tl.GetTrackCount('video'),
-                "TL.GetTrackCount('audio')": lambda: tl.GetTrackCount('audio'),
-                "TL.GetStartTimecode": lambda: tl.GetStartTimecode(),
-                "TL.GetCurrentTimecode": lambda: tl.GetCurrentTimecode(),
-                "TL.GetMarkers": lambda: tl.GetMarkers(),
-                "TL.GetSetting('')": lambda: tl.GetSetting(''),
-                "TL.GetUniqueId": lambda: tl.GetUniqueId(),
-                "TL.GetCurrentVideoItem": lambda: tl.GetCurrentVideoItem(),
-            }
-
-            for name, fn in tl_tests.items():
-                try:
-                    result = fn()
-                    val_str = str(result)[:100]
-                    results[name] = {"status": "OK", "value": val_str}
-                    print(f"  ✓ {name} = {val_str[:80]}")
-                except Exception as e:
-                    results[name] = {"status": "FAIL", "error": str(e)}
-                    print(f"  ✗ {name} ERROR: {e}")
-    else:
-        print("\n--- Timeline: SKIPPED (no timelines in project) ---")
-        # Create a test timeline so we can test more
-        print("  Creating test timeline...")
-        try:
-            tl = mp.CreateEmptyTimeline("API_Test_Timeline")
-            if tl:
-                print(f"  ✓ Created timeline: {tl.GetName()}")
-                results["MP.CreateEmptyTimeline"] = {"status": "OK", "value": tl.GetName()}
-
-                # Now test timeline methods
-                tl_tests = {
-                    "TL.GetName": lambda: tl.GetName(),
-                    "TL.GetStartFrame": lambda: tl.GetStartFrame(),
-                    "TL.GetEndFrame": lambda: tl.GetEndFrame(),
-                    "TL.GetTrackCount('video')": lambda: tl.GetTrackCount('video'),
-                    "TL.GetTrackCount('audio')": lambda: tl.GetTrackCount('audio'),
-                    "TL.GetStartTimecode": lambda: tl.GetStartTimecode(),
-                    "TL.GetCurrentTimecode": lambda: tl.GetCurrentTimecode(),
-                    "TL.GetMarkers": lambda: tl.GetMarkers(),
-                    "TL.GetSetting('')": lambda: tl.GetSetting(''),
-                    "TL.GetUniqueId": lambda: tl.GetUniqueId(),
-                    "TL.GetNodeGraph": lambda: tl.GetNodeGraph() is not None,
-                    "TL.GetMarkInOut": lambda: tl.GetMarkInOut(),
-                }
-
-                for name, fn in tl_tests.items():
-                    try:
-                        result = fn()
-                        val_str = str(result)[:100]
-                        results[name] = {"status": "OK", "value": val_str}
-                        print(f"  ✓ {name} = {val_str[:80]}")
-                    except Exception as e:
-                        results[name] = {"status": "FAIL", "error": str(e)}
-                        print(f"  ✗ {name} ERROR: {e}")
-        except Exception as e:
-            print(f"  ✗ Could not create timeline: {e}")
-
-    # ===== COLOR GROUPS =====
-    print("\n--- ColorGroup Object ---")
-    try:
-        groups = project.GetColorGroupsList()
-        if groups and len(groups) > 0:
-            cg = groups[0]
-            cg_tests = {
-                "CG.GetName": lambda: cg.GetName(),
-                "CG.GetPreClipNodeGraph": lambda: cg.GetPreClipNodeGraph() is not None,
-                "CG.GetPostClipNodeGraph": lambda: cg.GetPostClipNodeGraph() is not None,
-            }
-            for name, fn in cg_tests.items():
-                try:
-                    result = fn()
-                    val_str = str(result)[:100]
-                    results[name] = {"status": "OK", "value": val_str}
-                    print(f"  ✓ {name} = {val_str[:80]}")
-                except Exception as e:
-                    results[name] = {"status": "FAIL", "error": str(e)}
-                    print(f"  ✗ {name} ERROR: {e}")
-        else:
-            print("  No color groups found")
-    except Exception as e:
-        print(f"  ✗ GetColorGroupsList ERROR: {e}")
-
-    # ===== SUMMARY =====
-    print("\n" + "=" * 60)
-    ok = sum(1 for v in results.values() if v["status"] == "OK")
-    fail = sum(1 for v in results.values() if v["status"] == "FAIL")
-    print(f"RESULTS: {ok} passed, {fail} failed, {ok+fail} total")
-    print(f"Pass rate: {ok/(ok+fail)*100:.1f}%")
-
-    # Save results
-    with open('tests/live_api_results.json', 'w') as f:
-        json.dump(results, f, indent=2)
-    print(f"\nDetailed results saved to tests/live_api_results.json")
-
-if __name__ == "__main__":
-    test_api()

package/mcps/davinci-resolve-mcp/tests/test_marker_params.py

@@ -1,234 +0,0 @@
-import unittest
-
-import src.server as compound
-from tests._error_envelope_helpers import err_message
-
-
-def _strip_versioning(d):
-    """Return a copy of a result dict with the destructive_hook _versioning key removed."""
-    if not isinstance(d, dict):
-        return d
-    return {k: v for k, v in d.items() if k != "_versioning"}
-
-
-class TimelineStub:
-    """Hour-start timeline by default (start TC 01:00:00:00 @ 24fps -> frame 86400).
-
-    Timeline.AddMarker frameIds are RELATIVE to the timeline start (frame 0 ==
-    first frame), while GetCurrentTimecode/SetCurrentTimecode use absolute
-    timecode as displayed in the Resolve UI. Verified visually on Resolve
-    Studio 21 (2026-06-11); GetMarkers() echoes back whatever frameId was
-    passed, so only display-position conventions like these stubs encode can
-    catch absolute/relative mixups.
-    """
-
-    def __init__(self, fps="24", current_timecode="01:00:00:12", start_frame=86400):
-        self.fps = fps
-        self.current_timecode = current_timecode
-        self.start_frame = start_frame
-        self.add_calls = []
-        self.deleted_frames = []
-        self.update_custom_data_calls = []
-
-    def GetSetting(self, name):
-        if name == "timelineFrameRate":
-            return self.fps
-        return None
-
-    def GetCurrentTimecode(self):
-        return self.current_timecode
-
-    def GetStartFrame(self):
-        if self.start_frame is None:
-            raise RuntimeError("GetStartFrame unavailable")
-        return self.start_frame
-
-    def AddMarker(self, *args):
-        self.add_calls.append(args)
-        return True
-
-    def GetMarkers(self):
-        return {}
-
-    def DeleteMarkerAtFrame(self, frame):
-        self.deleted_frames.append(frame)
-        return True
-
-    def UpdateMarkerCustomData(self, frame, data):
-        self.update_custom_data_calls.append((frame, data))
-        return True
-
-    def GetCurrentClipThumbnailImage(self):
-        return None
-
-
-class FiveArgMarkerStub:
-    def __init__(self):
-        self.add_calls = []
-
-    def AddMarker(self, *args):
-        if len(args) == 6:
-            raise TypeError("customData overload unavailable")
-        self.add_calls.append(args)
-        return True
-
-
-class TimelineMarkerParamTest(unittest.TestCase):
-    def setUp(self):
-        self.original_get_tl = compound._get_tl
-        self.original_is_destructive = compound._destructive_hook.is_destructive
-        self.timeline = TimelineStub()
-        compound._get_tl = lambda: (None, self.timeline, None)
-        compound._destructive_hook.is_destructive = lambda *args, **kwargs: False
-
-    def tearDown(self):
-        compound._get_tl = self.original_get_tl
-        compound._destructive_hook.is_destructive = self.original_is_destructive
-
-    def test_add_accepts_frame_id_alias_and_defaults_name_duration(self):
-        # Raw frame params are already relative to the timeline start and must
-        # not be reinterpreted, even on an hour-start timeline.
-        out = compound.timeline_markers(
-            "add",
-            {
-                "frame_id": "42",
-                "color": "blue",
-                "note": "Needs review",
-                "customData": "marker-1",
-            },
-        )
-
-        self.assertEqual(_strip_versioning(out), {"success": True, "frame": 42})
-        self.assertEqual(
-            self.timeline.add_calls[-1],
-            (42, "Blue", "Needs review", "Needs review", 1, "marker-1"),
-        )
-
-    def test_add_defaults_to_current_playhead_relative_to_start(self):
-        # Playhead TC 01:00:00:12 on an hour-start timeline is marker frame 12.
-        out = compound.timeline_markers("add", {"color": "green"})
-
-        self.assertEqual(_strip_versioning(out), {"success": True, "frame": 12})
-        self.assertEqual(
-            self.timeline.add_calls[-1],
-            (12, "Green", "Marker", "", 1, ""),
-        )
-
-    def test_add_accepts_timecode_with_nominal_ntsc_rate(self):
-        # 01:00:10:00 @ 23.976 (nominal 24) is 86640 absolute -> 240 relative.
-        self.timeline.fps = "23.976"
-
-        out = compound.timeline_markers(
-            "add",
-            {"timecode": "01:00:10:00", "color": "red", "name": "TC"},
-        )
-
-        self.assertEqual(_strip_versioning(out), {"success": True, "frame": 240})
-        self.assertEqual(
-            self.timeline.add_calls[-1],
-            (240, "Red", "TC", "", 1, ""),
-        )
-
-    def test_add_timecode_below_start_treated_as_elapsed(self):
-        # A timecode before the timeline start timecode cannot be absolute;
-        # treat it as elapsed time from the first frame.
-        out = compound.timeline_markers(
-            "add",
-            {"timecode": "00:00:10:00", "color": "red", "name": "Elapsed"},
-        )
-
-        self.assertEqual(_strip_versioning(out), {"success": True, "frame": 240})
-
-    def test_add_timecode_on_zero_start_timeline(self):
-        self.timeline.start_frame = 0
-
-        out = compound.timeline_markers(
-            "add",
-            {"timecode": "00:00:10:00", "color": "red", "name": "ZeroStart"},
-        )
-
-        self.assertEqual(_strip_versioning(out), {"success": True, "frame": 240})
-
-    def test_add_playhead_without_start_frame_keeps_absolute(self):
-        # If GetStartFrame is unavailable the conversion cannot be rebased;
-        # fall back to the unrebased frame instead of erroring.
-        self.timeline.start_frame = None
-
-        out = compound.timeline_markers("add", {"color": "green"})
-
-        self.assertEqual(_strip_versioning(out), {"success": True, "frame": 86412})
-
-    def test_delete_at_frame_accepts_frame_id_alias(self):
-        out = compound.timeline_markers("delete_at_frame", {"frameId": 123})
-
-        self.assertEqual(_strip_versioning(out), {"success": True})
-        self.assertEqual(self.timeline.deleted_frames, [123])
-
-    def test_delete_at_frame_accepts_timecode_relative_to_start(self):
-        # Stored marker keys are relative, so timecode lookups must rebase to
-        # match the stored key.
-        out = compound.timeline_markers("delete_at_frame", {"timecode": "01:00:00:12"})
-
-        self.assertEqual(_strip_versioning(out), {"success": True})
-        self.assertEqual(self.timeline.deleted_frames, [12])
-
-    def test_update_custom_data_accepts_timecode_relative_to_start(self):
-        out = compound.timeline_markers(
-            "update_custom_data",
-            {"timecode": "01:00:00:12", "customData": "marker-2"},
-        )
-
-        self.assertEqual(_strip_versioning(out), {"success": True})
-        self.assertEqual(self.timeline.update_custom_data_calls, [(12, "marker-2")])
-
-    def test_current_timeline_frame_id_stays_absolute(self):
-        # Non-marker callers (duplicate-clip record frames) need the absolute
-        # frame that matches TimelineItem.GetStart().
-        frame, err = compound._current_timeline_frame_id(self.timeline)
-
-        self.assertIsNone(err)
-        self.assertEqual(frame, 86412)
-
-    def test_marker_display_frame_rebases_stored_markers_to_absolute(self):
-        # Contact sheets drive SetCurrentTimecode (absolute), so stored
-        # relative marker frames must be rebased the other way.
-        self.assertEqual(compound._marker_display_frame(self.timeline, 12), 86412)
-        # Legacy markers stored at absolute frames still sample the intended
-        # spot instead of pointing past the end of the timeline.
-        self.assertEqual(compound._marker_display_frame(self.timeline, 86412), 86412)
-        self.timeline.start_frame = 0
-        self.assertEqual(compound._marker_display_frame(self.timeline, 12), 12)
-
-    def test_invalid_timecode_returns_error(self):
-        out = compound.timeline_markers("add", {"timecode": "01:00:00"})
-
-        self.assertEqual(err_message(out), "timecode must use HH:MM:SS:FF format")
-
-    def test_get_thumbnail_returns_error_dict_when_resolve_returns_nil(self):
-        out = compound.timeline_markers("get_thumbnail")
-
-        self.assertEqual(out["success"], False)
-        self.assertIsNone(out["thumbnail"])
-        self.assertIn("did not return a thumbnail", out["error"])
-
-    def test_add_marker_falls_back_to_five_arg_overload_when_custom_data_empty(self):
-        target = FiveArgMarkerStub()
-
-        out = compound._add_marker(
-            target,
-            {
-                "frame": 12,
-                "color": "Blue",
-                "name": "Fallback",
-                "note": "",
-                "duration": 1,
-                "custom_data": "",
-            },
-        )
-
-        self.assertEqual(out, {"success": True, "frame": 12})
-        self.assertEqual(target.add_calls, [(12, "Blue", "Fallback", "", 1)])
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_mcp_prompts.py

@@ -1,77 +0,0 @@
-"""F2 contract test — five workflow prompts are registered on the mcp instance.
-
-See local/design/agentic-flow-improvements-gameplan-2.md §3 task F2.
-"""
-import unittest
-
-
-class McpPromptsTest(unittest.TestCase):
-    def test_workflow_prompts_are_registered(self):
-        from src.server import mcp
-        expected = {
-            "analyze_and_propose_grade",
-            "match_bin_to_hero",
-            "verify_timeline_coverage",
-            "open_and_analyze_selection",
-            "prep_color_handoff",
-        }
-        registered = set()
-        # FastMCP exposes prompts via _prompt_manager._prompts.
-        if hasattr(mcp, "_prompt_manager"):
-            pm = mcp._prompt_manager
-            if hasattr(pm, "_prompts"):
-                registered = set(pm._prompts.keys())
-        if not registered:
-            self.skipTest("FastMCP prompt manager internals changed; skipping check")
-        self.assertTrue(
-            expected.issubset(registered),
-            f"missing prompts: {expected - registered}"
-        )
-
-    def test_match_bin_to_hero_template_takes_args(self):
-        """The prompt body must interpolate hero_clip_id and method."""
-        from src.server import match_bin_to_hero
-        body = match_bin_to_hero("hero-uuid-123", method="cdl_delta")
-        self.assertIn("hero-uuid-123", body)
-        self.assertIn("cdl_delta", body)
-        self.assertIn("bulk_match_to_hero", body)
-        self.assertIn("dry_run", body)
-
-    def test_analyze_and_propose_grade_invokes_color_pipeline(self):
-        from src.server import analyze_and_propose_grade
-        body = analyze_and_propose_grade("clip-xyz")
-        self.assertIn("clip-xyz", body)
-        self.assertIn("grade_evidence_base", body)
-        self.assertIn("propose_grade", body)
-        self.assertIn('"execute": false', body)
-        # Must not auto-execute — that's the human-in-the-loop guard rail.
-        self.assertIn("Wait for explicit confirmation", body)
-
-    def test_verify_timeline_coverage_references_partial_success(self):
-        """The prompt should teach the agent to surface failed_clip_ids on partial success."""
-        from src.server import verify_timeline_coverage
-        body = verify_timeline_coverage()
-        self.assertIn("partial_success", body)
-        self.assertIn("failed_clip_ids", body)
-        self.assertIn("provenance", body)
-
-    def test_open_and_analyze_selection_starts_with_control_panel(self):
-        from src.server import open_and_analyze_selection
-        body = open_and_analyze_selection()
-        self.assertIn("open_control_panel", body)
-        self.assertIn("analyze_clip", body)
-        self.assertIn("commit_vision", body)
-
-    def test_prep_color_handoff_writes_to_safe_location(self):
-        """The prompt must NOT direct writes beside source media."""
-        from src.server import prep_color_handoff
-        body = prep_color_handoff()
-        self.assertIn("davinci-resolve-mcp-analysis", body)
-        self.assertIn("Do not write beside source media", body)
-        # Custom output dir is respected when provided.
-        custom = prep_color_handoff("/Users/x/handoff_dir")
-        self.assertIn("/Users/x/handoff_dir", custom)
-
-
-if __name__ == "__main__":
-    unittest.main()