@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,277 +0,0 @@
-#!/usr/bin/env python3
-"""Live validation for the Phase E edit engine (selects / tighten / swap).
-
-Creates a DISPOSABLE Resolve project with synthetic media (ffmpeg testsrc +
-macOS `say` speech), analyzes it headlessly, commits synthetic vision, then
-runs all three loops end-to-end through the real MCP tool functions:
-
-  plan_selects → execute_selects   (new timeline, additive)
-  plan_tighten → execute_tighten   (lifts applied to a DUPLICATE)
-  plan_swap    → execute_swap      (item replaced in place)
-
-Never touches source media destructively; the pilot project is deleted at
-the end (best effort — DeleteProject is flaky on some builds). The user's
-current project is restored.
-
-Run: venv/bin/python tests/live_edit_engine_validation.py
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-import subprocess
-import sys
-import tempfile
-import time
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-PILOT = f"edit_engine_pilot_{time.strftime('%H%M%S')}"
-MEDIA_DIR = tempfile.mkdtemp(prefix="drm-edit-engine-media-")
-
-CHECKS: list[tuple[str, bool, str]] = []
-
-
-def check(name: str, ok: bool, detail: str = "") -> None:
-    CHECKS.append((name, bool(ok), detail))
-    print(f"  [{'PASS' if ok else 'FAIL'}] {name}" + (f" — {detail}" if detail else ""))
-
-
-def synth_clip(name: str, *, speech: str, speech_at: float, duration: float, pattern: str) -> str:
-    """Synthetic clip: testsrc video + silence with a spoken phrase at speech_at."""
-    aiff = os.path.join(MEDIA_DIR, f"{name}.aiff")
-    subprocess.run(["say", "-o", aiff, speech], check=True)
-    out = os.path.join(MEDIA_DIR, f"{name}.mp4")
-    delay_ms = int(speech_at * 1000)
-    subprocess.run([
-        "ffmpeg", "-y",
-        "-f", "lavfi", "-i", f"{pattern}=duration={duration}:size=640x360:rate=24",
-        "-i", aiff,
-        "-filter_complex", f"[1:a]adelay={delay_ms}|{delay_ms},apad[a]",
-        "-map", "0:v", "-map", "[a]",
-        "-c:v", "libx264", "-preset", "ultrafast", "-c:a", "aac", "-t", str(duration),
-        out,
-    ], check=True, capture_output=True)
-    return out
-
-
-def main() -> int:
-    print(f"media dir: {MEDIA_DIR}")
-    clip_talk = synth_clip("talk_clip", speech="This is the main interview line for the pilot, spoken at the start.",
-                           speech_at=1.0, duration=20.0, pattern="testsrc")
-    clip_alt = synth_clip("alt_clip", speech="Alternate coverage line.", speech_at=1.0,
-                          duration=26.0, pattern="smptebars")
-
-    import src.server as s
-    from src.utils import media_analysis as ma
-    from src.utils import analysis_store, embeddings
-
-    r = s.get_resolve()
-    if r is None:
-        print("Resolve not available — aborting")
-        return 2
-    pm = r.GetProjectManager()
-    previous_project = pm.GetCurrentProject().GetName() if pm.GetCurrentProject() else None
-    print(f"previous project: {previous_project}")
-
-    proj = pm.CreateProject(PILOT)
-    check("disposable project created", proj is not None, PILOT)
-    if proj is None:
-        return 2
-    mp = proj.GetMediaPool()
-    imported = mp.ImportMedia([clip_talk, clip_alt])
-    check("media imported", bool(imported) and len(imported) == 2)
-    by_path = {}
-    for item in imported or []:
-        by_path[item.GetClipProperty("File Path")] = item
-
-    try:
-        # ── headless analysis (technical + transcript; vision committed below) ──
-        records = []
-        for path, item in by_path.items():
-            records.append({
-                "clip_id": item.GetUniqueId(),
-                "clip_name": item.GetName(),
-                "file_path": path,
-                "fps": 24.0,
-            })
-        pilot_project_id = proj.GetUniqueId() if hasattr(proj, "GetUniqueId") else None
-        plan = ma.build_plan(
-            project_name=PILOT,
-            project_id=pilot_project_id,
-            records=records,
-            target={"type": "paths", "paths": [r["file_path"] for r in records]},
-            params={"depth": "standard", "transcription": {"enabled": True, "allow_model_download": True},
-                    "vision": {"enabled": False}},
-        )
-        check("analysis plan", plan.get("success"), str(plan.get("error") or ""))
-        manifest = asyncio.run(ma.execute_plan_async(plan, params={
-            "depth": "standard", "transcription": {"enabled": True, "allow_model_download": True}}))
-        check("analysis executed", manifest.get("success"),
-              f"clips={manifest.get('successful_clip_count')}")
-        out_root = manifest["project_root"]
-        print(f"analysis root: {out_root}")
-
-        # ── synthetic vision commit (select potential + shots) ──
-        for row in manifest["clips"]:
-            record = row["record"]
-            is_talk = "talk" in str(record.get("clip_name"))
-            with open(row["analysis_json"]) as fh:
-                report = json.load(fh)
-            duration = (report.get("cut_analysis") or {}).get("duration_seconds") or 20.0
-            visual = {
-                "clip_summary": f"Synthetic pilot clip {record['clip_name']}.",
-                "editorial_classification": {
-                    "primary_use": "interview" if is_talk else "b_roll",
-                    "select_potential": "high" if is_talk else "medium",
-                },
-                "editing_notes": {"search_tags": ["pilot"], "best_moments": [], "continuity_flags": [], "qc_flags": []},
-                "shot_descriptions": [{
-                    "shot_index": 1,
-                    "time_seconds_start": 0.0,
-                    "time_seconds_end": float(duration),
-                    "description": "Full synthetic take." if is_talk else "Alternate synthetic take.",
-                    "qc_flags": [],
-                    "editorial": {"select_potential": "high" if is_talk else "medium",
-                                  "editorial_role": "coverage", "best_moment_present": False,
-                                  "best_moment": None, "pacing": "moderate"},
-                }],
-            }
-            commit = ma.commit_visual_analysis(
-                project_root=out_root, visual=visual, clip_id=record["clip_id"])
-            check(f"vision committed: {record['clip_name']}", commit.get("success"),
-                  str(commit.get("error") or ""))
-
-        # ── visual embeddings for the swap loop ──
-        built = embeddings.build_embeddings(out_root, kinds=("visual",), max_frames_per_clip=8)
-        check("visual embeddings", built.get("success"),
-              json.dumps(built.get("visual") or built.get("error")))
-
-        # ── E1: selects ──
-        plan1 = s.edit_engine("plan_selects", {"min_select_potential": "medium",
-                                               "timeline_name": "Pilot Selects"})
-        check("plan_selects", plan1.get("success") and plan1.get("decision_count", 0) >= 2,
-              f"decisions={plan1.get('decision_count')}")
-        gate = s.edit_engine("execute_selects", {"plan_id": plan1["plan_id"]})
-        check("execute_selects gated", gate.get("status") == "confirmation_required")
-        done1 = s.edit_engine("execute_selects", {"plan_id": plan1["plan_id"],
-                                                  "confirm_token": gate.get("confirm_token")})
-        check("execute_selects", done1.get("success"),
-              f"timeline={done1.get('timeline_name')} appended={done1.get('appended')} readback={done1.get('readback')}")
-
-        # ── E2: tighten (talk clip has dead air after ~5s of speech) ──
-        # Build a dedicated timeline with just the talk clip.
-        talk_item = by_path[clip_talk if clip_talk in by_path else ma.normalize_path(clip_talk)]
-        tl2 = mp.CreateTimelineFromClips("Pilot Tighten Base", [talk_item])
-        check("tighten base timeline", tl2 is not None)
-        proj.SetCurrentTimeline(tl2)
-        plan2 = s.edit_engine("plan_tighten", {"min_pause_seconds": 2.0})
-        check("plan_tighten", plan2.get("success") and plan2.get("lift_count", 0) >= 1,
-              f"lifts={plan2.get('lift_count')} est_removed={plan2.get('estimated_removed_seconds')}s "
-              f"skipped={plan2.get('skipped')}")
-        if plan2.get("success"):
-            gate2 = s.edit_engine("execute_tighten", {"plan_id": plan2["plan_id"]})
-            check("execute_tighten gated", gate2.get("status") == "confirmation_required")
-            done2 = s.edit_engine("execute_tighten", {"plan_id": plan2["plan_id"],
-                                                      "confirm_token": gate2.get("confirm_token")})
-            removed = (done2.get("readback") or {}).get("removed_seconds")
-            after_dur = ((done2.get("readback") or {}).get("after") or {}).get("duration_seconds")
-            check("execute_tighten",
-                  done2.get("success") and (removed or 0) > 5.0 and (after_dur or 0) > 1.0,
-                  f"variant={done2.get('variant_timeline')} removed={removed}s kept={after_dur}s "
-                  f"lifts={done2.get('lifts_applied')}")
-            original, _ = s._find_timeline_by_name(proj, "Pilot Tighten Base")
-            check("original untouched", original is not None)
-            # Phase 2 hardening: readback carries a cross-name structural diff.
-            sdiff = (done2.get("readback") or {}).get("structural_diff") or {}
-            sdiff_summary = sdiff.get("summary") or {}
-            check("tighten structural diff in readback",
-                  bool(sdiff_summary) and sdiff_summary.get("before_clip_count", 0) >= 1
-                  and not sdiff.get("error"),
-                  f"summary={sdiff_summary}")
-            # And the standalone action agrees with the readback.
-            live_diff = s.timeline_versioning("diff_timelines", {
-                "from_timeline": "Pilot Tighten Base",
-                "to_timeline": done2.get("variant_timeline"),
-            })
-            check("diff_timelines action",
-                  live_diff.get("success") and live_diff.get("summary") == sdiff_summary,
-                  f"summary={live_diff.get('summary')}")
-            # #67: the tightened variant must carry audio, not come out silent.
-            t_acct = (done2.get("readback") or {}).get("audio_accounting") or {}
-            check("tighten variant carries audio",
-                  t_acct.get("variant_audio_items", 0) >= 1
-                  and t_acct.get("planned_audio_ranges", 0) >= 1,
-                  f"audio_accounting={t_acct}")
-            v_tl, _ = s._find_timeline_by_name(proj, done2.get("variant_timeline"))
-            if v_tl is not None:
-                audio_items = v_tl.GetItemListInTrack("audio", 1) or []
-                check("tighten variant A1 not empty", len(audio_items) >= 1,
-                      f"A1 items={len(audio_items)}")
-
-        # ── E3: swap (replace the selects timeline's first item) ──
-        selects_tl, _ = s._find_timeline_by_name(proj, done1.get("timeline_name"))
-        proj.SetCurrentTimeline(selects_tl)
-        items = s._edit_engine_collect_items(selects_tl)
-        # Swap the talk item: its 20s slot can be filled by the 26s alternate.
-        first = next(r for r in items if "talk" in str(r.get("item_name")))
-        plan3 = s.edit_engine("plan_swap", {"timeline_start_frame": first["timeline_start_frame"],
-                                            "kind": "visual", "limit": 3})
-        check("plan_swap", plan3.get("success") and bool(plan3.get("alternates")),
-              f"alternates={len(plan3.get('alternates') or [])} error={plan3.get('error')} "
-              f"first_item={first}")
-        if plan3.get("success"):
-            gate3 = s.edit_engine("execute_swap", {"plan_id": plan3["plan_id"], "alternate_index": 0})
-            check("execute_swap gated", gate3.get("status") == "confirmation_required")
-            done3 = s.edit_engine("execute_swap", {"plan_id": plan3["plan_id"], "alternate_index": 0,
-                                                   "confirm_token": gate3.get("confirm_token")})
-            check("execute_swap", done3.get("success"),
-                  f"replacement={done3.get('replacement')} readback={done3.get('readback')}")
-            # Phase 2 hardening: per-track-type symmetry. The replacement
-            # appends linked video+audio after a video + linked-audio lift,
-            # so item counts per track type must be unchanged.
-            rb = done3.get("readback") or {}
-            counts_before = (rb.get("before") or {}).get("track_counts") or {}
-            counts_after = (rb.get("after") or {}).get("track_counts") or {}
-            accounting = rb.get("audio_accounting") or {}
-            check("swap track-count symmetry",
-                  bool(counts_before) and counts_before == counts_after,
-                  f"before={counts_before} after={counts_after} accounting={accounting}")
-            check("swap lifted linked audio explicitly",
-                  accounting.get("video_items_lifted", 0) >= 1
-                  and accounting.get("audio_items_lifted", 0) >= 1,
-                  f"accounting={accounting}")
-
-        # ── readback: brain_edits rows with rationale ──
-        from src.utils import timeline_brain_db
-        conn = timeline_brain_db.connect(out_root)
-        rows = conn.execute(
-            "SELECT edit_type, rationale FROM brain_edits WHERE edit_type LIKE 'edit_engine.%' ORDER BY id"
-        ).fetchall()
-        kinds = sorted({str(r["edit_type"]) for r in rows})
-        check("brain_edits rationale rows", len(rows) >= 3, f"kinds={kinds}")
-        archived = conn.execute("SELECT COUNT(*) FROM timeline_versions").fetchone()[0]
-        check("timeline versions archived", archived >= 1, f"versions={archived}")
-
-    finally:
-        try:
-            from src.utils.project_cleanup import delete_project_safely
-            outcome = delete_project_safely(pm, PILOT, switch_to=previous_project)
-            if outcome["success"]:
-                print(f"cleanup: previous project restored; pilot deleted "
-                      f"(attempts={outcome['attempts']})")
-            else:
-                print(f"cleanup warning: disposable project '{outcome['leftover']}' "
-                      f"left in library ({outcome['detail']}) — delete it manually")
-        except Exception as exc:
-            print(f"cleanup warning: {exc}")
-
-    failures = [c for c in CHECKS if not c[1]]
-    print(f"\n{len(CHECKS) - len(failures)}/{len(CHECKS)} checks passed")
-    return 0 if not failures else 1
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

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

@@ -1,89 +0,0 @@
-"""Live validation for the #70-follow-up enum-settings fixes.
-
-Confirms, against a running DaVinci Resolve, that the live `resolve` handle
-exposes the enum constants the CreateSubtitlesFromAudio and CloudProject
-normalizers resolve against, and that human-readable settings resolve to those
-live enum keys/values with unknown keys dropped.
-
-Read-only: never calls CreateSubtitlesFromAudio or any CloudProject method.
-
-Run:
-  PYTHONPATH=. venv/bin/python tests/live_enum_settings_check.py
-"""
-import sys
-
-import src.server as s
-
-
-def main() -> int:
-    resolve = s.get_resolve()
-    if resolve is None:
-        print("FAIL: could not connect to a running DaVinci Resolve")
-        return 1
-    print(f"Connected: {resolve.GetProductName()} {resolve.GetVersionString()}")
-    failures = []
-
-    # --- Subtitles -----------------------------------------------------------
-    for name in ("SUBTITLE_LANGUAGE", "SUBTITLE_CAPTION_PRESET", "SUBTITLE_LINE_BREAK",
-                 "SUBTITLE_CHARS_PER_LINE", "SUBTITLE_GAP", "AUTO_CAPTION_KOREAN",
-                 "AUTO_CAPTION_NETFLIX", "AUTO_CAPTION_LINE_DOUBLE"):
-        if not hasattr(resolve, name):
-            failures.append(f"live handle missing subtitle const {name}")
-    sub_norm, sub_ignored = s._normalize_auto_caption_settings(
-        {"language": "korean", "preset": "netflix", "chars_per_line": 999,
-         "group_id": "junk"}, resolve)
-    print(f"subtitle normalized={sub_norm!r} ignored={sub_ignored!r}")
-    if sub_norm.get(getattr(resolve, "SUBTITLE_LANGUAGE", None)) != getattr(resolve, "AUTO_CAPTION_KOREAN", None):
-        failures.append("subtitle language did not resolve to live AUTO_CAPTION_KOREAN")
-    if sub_norm.get(getattr(resolve, "SUBTITLE_CHARS_PER_LINE", None)) != 60:
-        failures.append("subtitle chars_per_line not clamped to 60")
-    if "korean" in [str(v).lower() for v in sub_norm.values()]:
-        failures.append("raw 'korean' string leaked into subtitle settings")
-    if sub_ignored != ["group_id"]:
-        failures.append(f"unexpected subtitle ignored: {sub_ignored!r}")
-
-    # --- CloudProject --------------------------------------------------------
-    cloud_consts = ("CLOUD_SETTING_PROJECT_NAME", "CLOUD_SETTING_SYNC_MODE",
-                    "CLOUD_SYNC_PROXY_ONLY")
-    missing_cloud = [c for c in cloud_consts if not hasattr(resolve, c)]
-    if missing_cloud:
-        # Cloud constants may be absent on some installs — report, don't hard-fail.
-        print(f"NOTE: live handle missing cloud consts {missing_cloud} (cloud features?)")
-    else:
-        cl_norm, cl_ignored = s._normalize_cloud_settings(
-            {"project_name": "LiveCheck", "sync_mode": "proxy_only", "bogus": 1}, resolve)
-        print(f"cloud normalized={cl_norm!r} ignored={cl_ignored!r}")
-        if cl_norm.get(getattr(resolve, "CLOUD_SETTING_SYNC_MODE")) != getattr(resolve, "CLOUD_SYNC_PROXY_ONLY"):
-            failures.append("cloud sync_mode did not resolve to live CLOUD_SYNC_PROXY_ONLY")
-        if cl_norm.get(getattr(resolve, "CLOUD_SETTING_PROJECT_NAME")) != "LiveCheck":
-            failures.append("cloud project_name not keyed to CLOUD_SETTING_PROJECT_NAME")
-        if cl_ignored != ["bogus"]:
-            failures.append(f"unexpected cloud ignored: {cl_ignored!r}")
-
-    # --- Timeline.Export enum args (v2.54.1) --------------------------------
-    for name in ("EXPORT_FCPXML_1_10", "EXPORT_EDL", "EXPORT_NONE"):
-        if not hasattr(resolve, name):
-            failures.append(f"live handle missing export const {name}")
-    fcpxml_spec = s._timeline_export_spec({"type": "fcpxml"}, resolve)
-    edl_spec = s._timeline_export_spec({"type": "edl"}, resolve)
-    print(f"export fcpxml -> type={fcpxml_spec['export_type']!r} ({fcpxml_spec['export_type_name']}) "
-          f"subtype={fcpxml_spec['export_subtype']!r}")
-    print(f"export edl    -> type={edl_spec['export_type']!r} ({edl_spec['export_type_name']})")
-    if fcpxml_spec["export_type"] != getattr(resolve, "EXPORT_FCPXML_1_10", None):
-        failures.append("fcpxml did not resolve to live EXPORT_FCPXML_1_10 value")
-    if fcpxml_spec["export_type"] == "fcpxml":
-        failures.append("raw 'fcpxml' string would have been passed to Timeline.Export")
-    if edl_spec["export_type"] != getattr(resolve, "EXPORT_EDL", None):
-        failures.append("edl did not resolve to live EXPORT_EDL value")
-
-    if failures:
-        print("\nFAIL:")
-        for f in failures:
-            print(f"  - {f}")
-        return 1
-    print("\nPASS: live subtitle + cloud + export enum resolution verified (#70 follow-up)")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-"""Run the live Extension Authoring kernel probe."""
-
-from __future__ import annotations
-
-import argparse
-import sys
-import tempfile
-import types
-from pathlib import Path
-
-
-def _install_mcp_stubs() -> None:
-    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 Extension Authoring 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
-
-    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)
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--output-dir", type=Path, default=None)
-    parser.add_argument("--keep-open", action="store_true")
-    args = parser.parse_args()
-
-    _install_mcp_stubs()
-    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-    original_argv = sys.argv[:]
-    sys.argv = [sys.argv[0]]
-    try:
-        import src.server as server  # noqa: WPS433
-    finally:
-        sys.argv = original_argv
-
-    from src.utils.extension_authoring_live_probe import run_probe  # noqa: WPS433
-
-    output_dir = args.output_dir or Path(tempfile.mkdtemp(prefix="extension-authoring-probe-report_"))
-    report = run_probe(server, output_dir, keep_open=args.keep_open)
-    if report["counts"].get("error", 0):
-        return 1
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

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

@@ -1,230 +0,0 @@
-"""Diagnose why our v2.5.0 Fuses aren't registering.
-
-Tests three hypotheses:
-1. Is comp.AddTool working at all? (try a built-in: Background)
-2. Does Resolve register a HAND-WRITTEN minimal Fuse? (env check)
-3. Does Resolve register one of our GENERATED Fuses? (generator check)
-"""
-
-import os
-import subprocess
-import sys
-import time
-
-PROJECT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, PROJECT)
-
-from src.utils.platform import get_resolve_paths, get_resolve_plugin_paths
-
-paths = get_resolve_paths()
-os.environ["RESOLVE_SCRIPT_API"] = paths["api_path"]
-os.environ["RESOLVE_SCRIPT_LIB"] = paths["lib_path"]
-sys.path.insert(0, paths["modules_path"])
-
-import DaVinciResolveScript as dvr_script  # noqa: E402
-from src.utils import fuse_templates  # noqa: E402
-
-
-# Hand-written minimal Fuse — pure pass-through, no aux features.
-MINIMAL_FUSE = """\
--- @mcp-fuse name=McpMinimal kind=minimal type=tool
-FuRegisterClass("McpMinimal", CT_Tool, {
-    REGS_Category = "Fuses\\\\MCP",
-    REGS_OpIconString = "Mini",
-    REGS_OpDescription = "Hand-written minimal pass-through",
-})
-
-function Create()
-    InImage = self:AddInput("Input", "Input", {
-        LINKID_DataType = "Image",
-        LINK_Main = 1,
-    })
-    OutImage = self:AddOutput("Output", "Output", {
-        LINKID_DataType = "Image",
-        LINK_Main = 1,
-    })
-end
-
-function Process(req)
-    OutImage:Set(req, InImage:GetValue(req))
-end
-"""
-
-
-def main():
-    candidate = dvr_script.scriptapp("Resolve")
-    if candidate is not None:
-        try:
-            if candidate.GetVersion():
-                print("ABORT: Resolve is already running. Quit it first.")
-                sys.exit(1)
-        except Exception:
-            pass
-
-    fuses_dir = get_resolve_plugin_paths()["fuses_dir"]
-    os.makedirs(fuses_dir, exist_ok=True)
-
-    # Install BOTH hand-written and generated Fuses
-    installed = []
-
-    minimal_path = os.path.join(fuses_dir, "McpMinimal.fuse")
-    with open(minimal_path, "w") as f:
-        f.write(MINIMAL_FUSE)
-    installed.append(("minimal", "McpMinimal", minimal_path))
-    print(f"[OK] hand-written minimal: {os.path.basename(minimal_path)}")
-
-    gen_source = fuse_templates.color_matrix("McpGenerated", {"ops": ["brightness"]})
-    gen_path = os.path.join(fuses_dir, "McpGenerated.fuse")
-    with open(gen_path, "w") as f:
-        f.write(gen_source)
-    installed.append(("generated", "McpGenerated", gen_path))
-    print(f"[OK] generated color_matrix: {os.path.basename(gen_path)}")
-
-    # Print what's in the generated file for visual inspection
-    print("\n=== Generated Fuse first 40 lines ===")
-    with open(gen_path) as f:
-        for i, line in enumerate(f):
-            if i >= 40:
-                break
-            print(f"  {i+1:3d}| {line.rstrip()}")
-
-    handle = None
-    try:
-        print("\n=== Launching Resolve ===")
-        subprocess.Popen(["open", "/Applications/DaVinci Resolve/DaVinci Resolve.app"])
-
-        for i in range(60):
-            time.sleep(2)
-            cand = dvr_script.scriptapp("Resolve")
-            if cand is not None:
-                try:
-                    if cand.GetVersion():
-                        handle = cand
-                        print(f"  Connected after {(i+1)*2}s")
-                        break
-                except Exception:
-                    continue
-        if handle is None:
-            print("ABORT: Resolve did not respond")
-            sys.exit(1)
-
-        # Build a project + timeline + Fusion-composition clip so we have a
-        # real per-clip Fusion comp that accepts AddTool.
-        pm = handle.GetProjectManager()
-        try:
-            pm.DeleteProject("McpDiag")
-        except Exception:
-            pass
-        project = pm.CreateProject("McpDiag")
-        if project is None:
-            print("ABORT: CreateProject failed")
-            sys.exit(1)
-        mp = project.GetMediaPool()
-        timeline = mp.CreateEmptyTimeline("McpDiagTimeline")
-        if timeline is None:
-            print("ABORT: CreateEmptyTimeline failed")
-            sys.exit(1)
-        timeline.InsertFusionCompositionIntoTimeline()
-        handle.OpenPage("fusion")
-        time.sleep(2)
-
-        fusion = handle.Fusion()
-        comp = fusion.GetCurrentComp()
-        if comp is None:
-            print("ABORT: GetCurrentComp returned None")
-            sys.exit(1)
-        print(f"  Comp: {comp.GetAttrs().get('COMPS_Name', '?')}")
-
-        # Give Fusion an extra moment to finish indexing Fuses
-        print("\n  Waiting 5s for Fuse registry to settle...")
-        time.sleep(5)
-
-        def _add(tool_type):
-            comp.Lock()
-            try:
-                return comp.AddTool(tool_type, -1, -1)
-            finally:
-                comp.Unlock()
-
-        print("\n=== Test 1: Built-in tool baseline ===")
-        try:
-            t = _add("Background")
-            if t is None:
-                print("  [FAIL] AddTool('Background') returned None — Lock/Unlock didn't help")
-            else:
-                attrs = t.GetAttrs() or {}
-                print(f"  [OK]   AddTool('Background') -> {attrs.get('TOOLS_RegID', '?')}")
-                t.Delete()
-        except Exception as e:
-            print(f"  [ERR]  {e}")
-
-        print("\n=== Test 2: Hand-written minimal Fuse ===")
-        try:
-            t = _add("McpMinimal")
-            if t is None:
-                print("  [FAIL] AddTool('McpMinimal') returned None")
-                print("         → Resolve did not register the hand-written Fuse")
-            else:
-                attrs = t.GetAttrs() or {}
-                print(f"  [OK]   AddTool('McpMinimal') -> {attrs.get('TOOLS_RegID', '?')}")
-                t.Delete()
-        except Exception as e:
-            print(f"  [ERR]  {e}")
-
-        print("\n=== Test 3: Generated color_matrix Fuse ===")
-        try:
-            t = _add("McpGenerated")
-            if t is None:
-                print("  [FAIL] AddTool('McpGenerated') returned None")
-                print("         → Generator output rejected by Fusion's Lua loader")
-            else:
-                attrs = t.GetAttrs() or {}
-                print(f"  [OK]   AddTool('McpGenerated') -> {attrs.get('TOOLS_RegID', '?')}")
-                t.Delete()
-        except Exception as e:
-            print(f"  [ERR]  {e}")
-
-        # As a tiebreaker: enumerate ALL registered tool classes, see if our names appear
-        print("\n=== Test 4: Dump tool registry (filter for Mcp*) ===")
-        try:
-            reg = fusion.GetRegList(2)  # CT_Tool = 2 typically
-            if reg:
-                mcp_keys = [k for k in reg.keys() if isinstance(k, str) and "Mcp" in k]
-                if mcp_keys:
-                    for k in mcp_keys:
-                        print(f"  registered: {k}")
-                else:
-                    print("  No Mcp* classes in registry — registration failed")
-            else:
-                print(f"  GetRegList returned: {reg}")
-        except Exception as e:
-            print(f"  GetRegList not available: {e}")
-
-    finally:
-        print("\n=== Cleanup ===")
-        for kind, name, path in installed:
-            try:
-                os.unlink(path)
-                print(f"  removed: {os.path.basename(path)}")
-            except OSError:
-                pass
-        try:
-            if 'pm' in locals() and pm is not None:
-                cur = pm.GetCurrentProject()
-                if cur is not None:
-                    pm.CloseProject(cur)
-                pm.DeleteProject("McpDiag")
-                print("  removed: McpDiag project")
-        except Exception:
-            pass
-        try:
-            h = dvr_script.scriptapp("Resolve")
-            if h is not None:
-                print("  Quitting Resolve...")
-                h.Quit()
-        except Exception:
-            pass
-
-
-if __name__ == "__main__":
-    main()