@hybridlabor-api/aos 4.3.0 → 4.4.0

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

@@ -1,157 +0,0 @@
-"""Unit tests for src/utils/analysis_runs.py (C6 hardening — run scoping).
-
-No Resolve required.
-"""
-
-from __future__ import annotations
-
-import os
-import shutil
-import tempfile
-import unittest
-
-from src.utils import analysis_runs, brain_edits, timeline_brain_db
-
-
-class RunScoping(unittest.TestCase):
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="analysis_runs_test_")
-        self.project_root = os.path.join(self.tmp, "project")
-        os.makedirs(self.project_root, exist_ok=True)
-        analysis_runs._reset_for_test()
-
-    def tearDown(self) -> None:
-        analysis_runs._reset_for_test()
-        timeline_brain_db.reset_for_test(self.project_root)
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_begin_run_persists_and_sets_current(self) -> None:
-        self.assertIsNone(analysis_runs.current_run_id())
-        result = analysis_runs.begin_run(
-            project_root=self.project_root,
-            label="rough cut tighten",
-            initiator="brain.chat",
-        )
-        self.assertTrue(result["success"])
-        run_id = result["analysis_run_id"]
-        self.assertEqual(analysis_runs.current_run_id(), run_id)
-        self.assertEqual(analysis_runs.current_run_initiator(), "brain.chat")
-
-        # DB row exists.
-        run = analysis_runs.get_run(self.project_root, run_id)
-        self.assertIsNotNone(run)
-        self.assertEqual(run["label"], "rough cut tighten")
-        self.assertEqual(run["initiator"], "brain.chat")
-        self.assertIsNone(run["ended_at"])
-
-    def test_end_run_aggregates_brain_edits_into_summary(self) -> None:
-        opened = analysis_runs.begin_run(
-            project_root=self.project_root, label="gap close",
-            initiator="brain.chat",
-        )
-        run_id = opened["analysis_run_id"]
-        # Simulate two declared edits under this run with the same metric.
-        for before, after in [(120.0, 110.0), (110.0, 100.0)]:
-            brain_edits.log_brain_edit(
-                project_root=self.project_root,
-                analysis_run_id=run_id,
-                edit_type="timeline.delete_clips",
-                target_metric="duration_seconds",
-                before_value=before,
-                after_value=after,
-                project_name="proj",
-            )
-        ended = analysis_runs.end_run(project_root=self.project_root)
-        self.assertTrue(ended["success"])
-        self.assertEqual(ended["analysis_run_id"], run_id)
-        summary = ended["summary"]
-        self.assertEqual(summary["edit_count"], 2)
-        per_metric = summary["per_metric"]
-        self.assertIn("duration_seconds", per_metric)
-        bucket = per_metric["duration_seconds"]
-        self.assertEqual(bucket["edit_count"], 2)
-        self.assertEqual(bucket["first_before"], 120.0)
-        self.assertEqual(bucket["last_after"], 100.0)
-        self.assertEqual(bucket["total_delta"], -20.0)
-        # current_run_id cleared after end_run.
-        self.assertIsNone(analysis_runs.current_run_id())
-
-    def test_end_run_handles_no_active_run(self) -> None:
-        result = analysis_runs.end_run(project_root=self.project_root)
-        self.assertFalse(result["success"])
-        self.assertIn("no active run", (result["error"].get("message","") if isinstance(result["error"], dict) else result["error"]))
-
-    def test_begin_run_warns_when_replacing_active_run(self) -> None:
-        first = analysis_runs.begin_run(project_root=self.project_root, label="first")
-        second = analysis_runs.begin_run(project_root=self.project_root, label="second")
-        # Both should persist; current_run_id should now point at second.
-        self.assertEqual(analysis_runs.current_run_id(), second["analysis_run_id"])
-        # First run is still in the DB even though it's no longer active.
-        first_row = analysis_runs.get_run(self.project_root, first["analysis_run_id"])
-        self.assertIsNotNone(first_row)
-
-    def test_end_run_specific_id_when_not_active(self) -> None:
-        opened = analysis_runs.begin_run(project_root=self.project_root)
-        run_id = opened["analysis_run_id"]
-        analysis_runs._reset_for_test()  # simulate a process restart
-        ended = analysis_runs.end_run(
-            project_root=self.project_root, analysis_run_id=run_id,
-        )
-        self.assertTrue(ended["success"])
-        self.assertEqual(ended["analysis_run_id"], run_id)
-
-    def test_list_runs_returns_newest_first(self) -> None:
-        ids = []
-        for label in ("first", "second", "third"):
-            ids.append(analysis_runs.begin_run(
-                project_root=self.project_root, label=label,
-            )["analysis_run_id"])
-        rows = analysis_runs.list_runs(self.project_root, limit=10)
-        # Newest first.
-        self.assertEqual([r["label"] for r in rows][0], "third")
-        self.assertEqual(len(rows), 3)
-
-
-class HookIntegration(unittest.TestCase):
-    """Sanity-check that the destructive_hook helpers consult analysis_runs."""
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="hook_integration_test_")
-        self.project_root = os.path.join(self.tmp, "project")
-        os.makedirs(self.project_root, exist_ok=True)
-        analysis_runs._reset_for_test()
-
-    def tearDown(self) -> None:
-        analysis_runs._reset_for_test()
-        timeline_brain_db.reset_for_test(self.project_root)
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_extract_analysis_run_id_uses_current_run_when_no_param(self) -> None:
-        from src.utils import destructive_hook
-        opened = analysis_runs.begin_run(project_root=self.project_root)
-        try:
-            run_id = destructive_hook._extract_analysis_run_id(None)
-            self.assertEqual(run_id, opened["analysis_run_id"])
-            # Explicit param wins.
-            override = destructive_hook._extract_analysis_run_id({"analysis_run_id": "explicit_xyz"})
-            self.assertEqual(override, "explicit_xyz")
-        finally:
-            analysis_runs.end_run(project_root=self.project_root)
-
-    def test_extract_initiator_uses_current_run_when_no_param(self) -> None:
-        from src.utils import destructive_hook
-        analysis_runs.begin_run(
-            project_root=self.project_root, initiator="brain.chat",
-        )
-        try:
-            self.assertEqual(destructive_hook._extract_initiator(None), "brain.chat")
-            self.assertEqual(
-                destructive_hook._extract_initiator({"initiator": "user.explicit"}),
-                "user.explicit",
-            )
-        finally:
-            analysis_runs.end_run(project_root=self.project_root)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,366 +0,0 @@
-"""Unit tests for src/utils/analysis_store.py (C1 — DB-canonical clip analysis).
-
-No Resolve required. Includes the Phase A round-trip guard: ingest → export
-must reproduce the report exactly (the export overlay only ever applies human
-rows). When a real sample analysis root is present on disk, its reports are
-round-tripped too (read-only: the DB used is always a temp directory).
-"""
-
-from __future__ import annotations
-
-import copy
-import json
-import os
-import shutil
-import tempfile
-import unittest
-
-from src.utils import analysis_store, timeline_brain_db
-
-# A real analyzed sample root (issue references: 20260517 sample). The test
-# only READS its analysis.json files; rows are written to a temp DB.
-REAL_SAMPLE_ROOT = os.path.expanduser(
-    "~/Documents/davinci-resolve-mcp-analysis/20260517_sample-fc314309e4"
-)
-
-
-def make_report(**overrides):
-    """A small but structurally faithful analysis report."""
-    report = {
-        "success": True,
-        "analysis_version": "0.2",
-        "analysis_signature": {"signature_hash": "abc123def456"},
-        "analysis_profile": {"depth": "standard", "vision_enabled": True},
-        "analyzed_at": "2026-06-10T00:00:00Z",
-        "source_file": "/media/sample clip.mp4",
-        "clip": {
-            "clip_id": "11111111-2222-3333-4444-555555555555",
-            "clip_name": "Sample Clip.mp4",
-            "media_id": "aaaa-bbbb",
-            "file_path": "/media/sample clip.mp4",
-            "bin_path": "Master/Bin 1",
-            "fps": 24.0,
-            "resolution": "1920x1080",
-            "media_type": "Video + Audio",
-        },
-        "summary": "Sample Clip.mp4, 20.0s, medium motion",
-        "technical_warnings": [],
-        "technical": {"format": {"duration_seconds": 20.0}},
-        "cut_analysis": {"cut_count": 2, "duration_seconds": 20.0},
-        "motion": {
-            "overall_motion_level": "medium",
-            "analysis_keyframes": [
-                {"index": 1, "time_seconds": 0.5, "selection_reason": "shot_start", "motion_peak": False},
-                {"index": 2, "time_seconds": 6.0, "selection_reason": "shot_representative", "motion_peak": True},
-                {"index": 3, "time_seconds": 14.0, "selection_reason": "shot_start", "motion_peak": False},
-            ],
-        },
-        "transcription": {
-            "success": True,
-            "segments": [
-                {"start": 0.0, "end": 4.0, "text": "hello there"},
-                {"start": 4.0, "end": 9.5, "text": "general kenobi"},
-            ],
-        },
-        "visual": {
-            "success": True,
-            "clip_summary": "A sample clip with two cuts.",
-            "clip_summary_oneliner": "Sample clip.",
-            "editorial_classification": {"primary_use": "b_roll", "select_potential": "medium"},
-            "content": {"locations": ["interior"], "actions": ["talking"]},
-            "shot_and_style": {"shot_sizes": ["medium"], "camera_motion": ["static"]},
-            "slate": {"slate_visible": False},
-            "editing_notes": {"best_moments": [], "search_tags": ["sample", "talking"]},
-            "shot_descriptions": [
-                {
-                    "shot_index": 1,
-                    "time_seconds_start": 0.0,
-                    "time_seconds_end": 5.2,
-                    "frame_indices_used": [1],
-                    "description": "Opening wide shot.",
-                    "qc_flags": [],
-                },
-                {
-                    "shot_index": 2,
-                    "time_seconds_start": 5.2,
-                    "time_seconds_end": 13.9,
-                    "frame_indices_used": [2],
-                    "description": "Medium shot, subject talks.",
-                    "qc_flags": ["soft_focus"],
-                },
-                {
-                    "shot_index": 3,
-                    "time_seconds_start": 13.9,
-                    "time_seconds_end": 20.0,
-                    "frame_indices_used": [3],
-                    "description": "Closing shot.",
-                    "qc_flags": [],
-                },
-            ],
-            "qc": {
-                "warnings": ["No slate is visible."],
-                "continuity_observations": [
-                    {
-                        "kind": "screen_direction",
-                        "shot_indices": [1, 2],
-                        "observation": "Direction flips between shots 1 and 2.",
-                        "confidence": "medium",
-                    }
-                ],
-                "coverage_gaps": ["No close-up coverage."],
-            },
-        },
-        "analysis_keyframes": [],
-        "clip_analysis_markers": {"marker_count": 0, "duration_seconds": 20.0},
-    }
-    report.update(overrides)
-    return report
-
-
-class AnalysisStoreTests(unittest.TestCase):
-    def setUp(self) -> None:
-        self.root = tempfile.mkdtemp(prefix="analysis-store-test-")
-        self.addCleanup(shutil.rmtree, self.root, True)
-        self.addCleanup(timeline_brain_db.close_all)
-
-    # ── schema ──────────────────────────────────────────────────────────────
-
-    def test_v9_tables_exist(self) -> None:
-        conn = timeline_brain_db.connect(self.root)
-        tables = {
-            row[0]
-            for row in conn.execute(
-                "SELECT name FROM sqlite_master WHERE type='table'"
-            ).fetchall()
-        }
-        for table in (
-            "clips",
-            "clip_aliases",
-            "analysis_reports",
-            "shots",
-            "subjective_fields",
-            "field_changelog",
-            "transcript_segments",
-            "frames",
-            "qc_observations",
-        ):
-            self.assertIn(table, tables)
-        self.assertGreaterEqual(timeline_brain_db._read_schema_version(conn), 9)
-
-    # ── round-trip guard ────────────────────────────────────────────────────
-
-    def test_ingest_export_round_trip_exact(self) -> None:
-        report = make_report()
-        original = json.loads(json.dumps(report, sort_keys=True, default=str))
-        result = analysis_store.ingest_report(self.root, report, clip_dir="sample-clip-mp4-abcdef123456")
-        self.assertTrue(result["success"], result)
-        exported = analysis_store.export_report(self.root, result["clip_uuid"])
-        self.assertEqual(original, exported)
-
-    def test_round_trip_real_sample_root(self) -> None:
-        clips_root = os.path.join(REAL_SAMPLE_ROOT, "clips")
-        if not os.path.isdir(clips_root):
-            self.skipTest("real sample root not present on this machine")
-        round_tripped = 0
-        for entry in sorted(os.listdir(clips_root)):
-            report_path = os.path.join(clips_root, entry, "analysis.json")
-            if not os.path.isfile(report_path):
-                continue
-            with open(report_path, "r", encoding="utf-8") as handle:
-                report = json.load(handle)
-            original = json.loads(json.dumps(report, sort_keys=True, default=str))
-            result = analysis_store.ingest_report(self.root, report, clip_dir=entry)
-            self.assertTrue(result["success"], result)
-            exported = analysis_store.export_report(self.root, result["clip_uuid"])
-            self.assertEqual(original, exported, f"round-trip drift for {entry}")
-            round_tripped += 1
-        self.assertGreater(round_tripped, 0)
-
-    def test_reingest_is_idempotent(self) -> None:
-        report = make_report()
-        first = analysis_store.ingest_report(self.root, report)
-        second = analysis_store.ingest_report(self.root, copy.deepcopy(report))
-        self.assertEqual(first["clip_uuid"], second["clip_uuid"])
-        # Second pass writes no new subjective rows (values unchanged).
-        self.assertEqual(second["subjective_fields_written"], 0)
-        conn = timeline_brain_db.connect(self.root)
-        n = conn.execute("SELECT COUNT(*) FROM clips").fetchone()[0]
-        self.assertEqual(n, 1)
-
-    # ── identity / lookup ───────────────────────────────────────────────────
-
-    def test_resolve_clip_uuid_by_any_alias(self) -> None:
-        report = make_report()
-        result = analysis_store.ingest_report(self.root, report, clip_dir="sample-clip-mp4-abcdef123456")
-        clip_uuid = result["clip_uuid"]
-        conn = timeline_brain_db.connect(self.root)
-        for ref in (
-            clip_uuid,
-            report["clip"]["clip_id"],
-            report["clip"]["media_id"],
-            report["clip"]["file_path"],
-            "sample-clip-mp4-abcdef123456",
-        ):
-            self.assertEqual(
-                analysis_store.resolve_clip_uuid(conn, ref), clip_uuid, f"failed for {ref!r}"
-            )
-        self.assertIsNone(analysis_store.resolve_clip_uuid(conn, "nope"))
-
-    def test_shot_uuid_stable_under_boundary_jitter(self) -> None:
-        a = analysis_store.shot_uuid_for("deadbeef0123", 5.2, 13.9)
-        b = analysis_store.shot_uuid_for("deadbeef0123", 5.4, 14.1)
-        self.assertEqual(a, b)
-        c = analysis_store.shot_uuid_for("deadbeef0123", 5.2, 18.0)
-        self.assertNotEqual(a, c)
-
-    # ── corrections ─────────────────────────────────────────────────────────
-
-    def test_human_correction_survives_reingest(self) -> None:
-        report = make_report()
-        result = analysis_store.ingest_report(self.root, report)
-        clip_uuid = result["clip_uuid"]
-        corr = analysis_store.record_human_correction(
-            self.root,
-            clip_ref=clip_uuid,
-            entity_type="shot",
-            entity_uuid=2,  # shot_index
-            field_path="description",
-            value="Corrected: tight medium, two cuts late.",
-            author="sam@bradfordoperations.com",
-            reason="fix machine description",
-        )
-        self.assertTrue(corr["success"], corr)
-        exported = analysis_store.export_report(self.root, clip_uuid)
-        self.assertEqual(
-            exported["visual"]["shot_descriptions"][1]["description"],
-            "Corrected: tight medium, two cuts late.",
-        )
-        # Machine re-ingest must not clobber the human row.
-        reingest = analysis_store.ingest_report(self.root, make_report())
-        self.assertGreaterEqual(reingest["subjective_fields_preserved_human"], 1)
-        exported = analysis_store.export_report(self.root, clip_uuid)
-        self.assertEqual(
-            exported["visual"]["shot_descriptions"][1]["description"],
-            "Corrected: tight medium, two cuts late.",
-        )
-        # Changelog recorded the correction.
-        conn = timeline_brain_db.connect(self.root)
-        rows = conn.execute(
-            "SELECT * FROM field_changelog WHERE new_source='human'"
-        ).fetchall()
-        self.assertEqual(len(rows), 1)
-
-    def test_clip_level_correction_and_clear(self) -> None:
-        report = make_report()
-        result = analysis_store.ingest_report(self.root, report)
-        clip_uuid = result["clip_uuid"]
-        analysis_store.record_human_correction(
-            self.root,
-            clip_ref=report["clip"]["clip_id"],
-            entity_type="clip",
-            entity_uuid=clip_uuid,
-            field_path="editorial_classification.select_potential",
-            value="high",
-            author="sam",
-        )
-        exported = analysis_store.export_report(self.root, clip_uuid)
-        self.assertEqual(
-            exported["visual"]["editorial_classification"]["select_potential"], "high"
-        )
-        cleared = analysis_store.clear_human_field(
-            self.root,
-            clip_ref=clip_uuid,
-            entity_type="clip",
-            entity_uuid=clip_uuid,
-            field_path="editorial_classification.select_potential",
-            author="sam",
-        )
-        self.assertTrue(cleared["success"])
-        self.assertEqual(cleared["cleared"], 1)
-        exported = analysis_store.export_report(self.root, clip_uuid)
-        self.assertEqual(
-            exported["visual"]["editorial_classification"]["select_potential"], "medium"
-        )
-
-    # ── project ingest (migration path) ─────────────────────────────────────
-
-    def test_ingest_project_with_corrections_sidecar(self) -> None:
-        clip_dir = os.path.join(self.root, "clips", "sample-clip-mp4-abcdef123456")
-        os.makedirs(clip_dir)
-        report = make_report()
-        with open(os.path.join(clip_dir, "analysis.json"), "w", encoding="utf-8") as handle:
-            json.dump(report, handle)
-        corrections = {
-            "schema_version": "2.0",
-            "clip_id": report["clip"]["clip_id"],
-            "current": {
-                "shot:2:description": {
-                    "value": "Human-corrected description.",
-                    "source": "human",
-                    "author": "sam",
-                    "timestamp": "2026-06-01T00:00:00Z",
-                }
-            },
-            "changelog": [],
-        }
-        with open(os.path.join(clip_dir, "corrections.json"), "w", encoding="utf-8") as handle:
-            json.dump(corrections, handle)
-
-        result = analysis_store.ingest_project(self.root)
-        self.assertTrue(result["success"], result)
-        self.assertEqual(result["ingested_count"], 1)
-        self.assertEqual(result["corrections_imported"], 1)
-        clip_uuid = result["ingested"][0]["clip_uuid"]
-        exported = analysis_store.export_report(self.root, clip_uuid)
-        self.assertEqual(
-            exported["visual"]["shot_descriptions"][1]["description"],
-            "Human-corrected description.",
-        )
-
-    # ── readers / status ────────────────────────────────────────────────────
-
-    def test_load_db_report_fallback_contract(self) -> None:
-        self.assertIsNone(
-            analysis_store.load_db_report(self.root, clip_dir="missing-aaaaaaaaaaaa")
-        )
-        report = make_report()
-        analysis_store.ingest_report(self.root, report, clip_dir="sample-clip-mp4-abcdef123456")
-        loaded = analysis_store.load_db_report(self.root, clip_dir="sample-clip-mp4-abcdef123456")
-        self.assertIsNotNone(loaded)
-        self.assertEqual(loaded["clip"]["clip_name"], "Sample Clip.mp4")
-
-    def test_db_status_counts(self) -> None:
-        analysis_store.ingest_report(self.root, make_report())
-        status = analysis_store.db_status(self.root)
-        self.assertTrue(status["success"])
-        self.assertTrue(status["canonical"])
-        self.assertEqual(status["counts"]["clips"], 1)
-        self.assertEqual(status["counts"]["shots"], 3)
-        self.assertEqual(status["counts"]["transcript_segments"], 2)
-        self.assertEqual(status["counts"]["frames"], 3)
-        self.assertGreaterEqual(status["counts"]["qc_observations"], 3)
-
-    def test_normalized_rows_match_report(self) -> None:
-        report = make_report()
-        result = analysis_store.ingest_report(self.root, report)
-        conn = timeline_brain_db.connect(self.root)
-        clip = conn.execute("SELECT * FROM clips").fetchone()
-        self.assertEqual(clip["clip_name"], "Sample Clip.mp4")
-        self.assertEqual(clip["overall_motion_level"], "medium")
-        self.assertEqual(clip["cut_count"], 2)
-        self.assertEqual(clip["shot_count"], 3)
-        self.assertEqual(clip["duration_seconds"], 20.0)
-        shots = conn.execute(
-            "SELECT * FROM shots ORDER BY shot_index"
-        ).fetchall()
-        self.assertEqual([s["shot_index"] for s in shots], [1, 2, 3])
-        self.assertEqual(shots[1]["description"], "Medium shot, subject talks.")
-        # Frame→shot mapping derived from frame_indices_used.
-        frame = conn.execute(
-            "SELECT shot_uuid FROM frames WHERE frame_index=2"
-        ).fetchone()
-        self.assertEqual(frame["shot_uuid"], shots[1]["shot_uuid"])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,56 +0,0 @@
-"""Drift guard: docs/reference/api-limitations.md tracks api_truth.
-
-The Blackmagic-facing limitations report is generated from the ``submit``-tagged
-entries in src/utils/api_truth.py by scripts/gen_api_limitations.py. This test
-fails when the committed doc drifts from what the generator would produce now, so
-adding or editing a ``submit`` entry forces a regenerate. It also asserts the doc
-exists, is marked generated, and that every catalogued submit kind is valid.
-"""
-import importlib.util
-import pathlib
-import unittest
-
-from src.utils.api_truth import API_TRUTH, submittable_limitations
-
-ROOT = pathlib.Path(__file__).resolve().parent.parent
-DOC = ROOT / "docs" / "reference" / "api-limitations.md"
-GEN = ROOT / "scripts" / "gen_api_limitations.py"
-
-
-def _load_generator():
-    spec = importlib.util.spec_from_file_location("gen_api_limitations", GEN)
-    mod = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(mod)
-    return mod
-
-
-class ApiLimitationsDocTest(unittest.TestCase):
-    def test_doc_matches_generator(self):
-        gen = _load_generator()
-        self.assertTrue(DOC.exists(), "api-limitations.md is missing — run the generator")
-        self.assertEqual(
-            DOC.read_text(),
-            gen.render(),
-            "api-limitations.md is stale; run: "
-            "venv/bin/python scripts/gen_api_limitations.py",
-        )
-
-    def test_doc_is_marked_generated(self):
-        self.assertIn("GENERATED FILE", DOC.read_text())
-
-    def test_submit_values_are_valid(self):
-        for e in API_TRUTH:
-            kind = e.get("submit")
-            self.assertIn(
-                kind, (None, "missing", "bug"),
-                f"entry {e.get('symbol')!r} has invalid submit={kind!r}",
-            )
-
-    def test_report_is_non_empty(self):
-        groups = submittable_limitations()
-        self.assertTrue(groups["missing"], "expected at least one missing-capability entry")
-        self.assertTrue(groups["bug"], "expected at least one bug entry")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,64 +0,0 @@
-"""Tests for the behaviorally-verified API truth ledger and its lookup action."""
-import unittest
-
-import src.server as s
-from src.utils.api_truth import lookup_api_truth, API_TRUTH
-
-
-class LookupTest(unittest.TestCase):
-    def test_no_query_returns_all(self):
-        self.assertEqual(len(lookup_api_truth()), len(API_TRUTH))
-
-    def test_query_matches_symbol_and_tags(self):
-        audio = lookup_api_truth("audio")
-        self.assertTrue(any("AutoSyncAudio" in e["symbol"] for e in audio))
-
-    def test_query_matches_reality_text(self):
-        res = lookup_api_truth("ellipsis")
-        self.assertTrue(any("Transcription" in e["symbol"] for e in res))
-
-    def test_case_insensitive(self):
-        self.assertEqual(
-            [e["symbol"] for e in lookup_api_truth("FUSION")],
-            [e["symbol"] for e in lookup_api_truth("fusion")],
-        )
-
-    def test_no_match(self):
-        self.assertEqual(lookup_api_truth("nonexistent-zzz"), [])
-
-    def test_source_track_selector_limitation_recorded(self):
-        # Issue #74: the Source Track Selector / insert-destination track is not
-        # controllable via the API. The verified-limitation entry must be findable
-        # by an agent searching for the track-targeting behavior.
-        hits = lookup_api_truth("track selector")
-        self.assertTrue(any("Source Track Selector" in e["symbol"] for e in hits))
-        entry = next(e for e in hits if "Source Track Selector" in e["symbol"])
-        self.assertIn("missing-method", entry["tags"])
-        self.assertNotIn("enum", entry["tags"])  # no mitigation required
-
-    def test_entries_well_formed(self):
-        for e in API_TRUTH:
-            self.assertIn("symbol", e)
-            self.assertIn("reality", e)
-            self.assertIn("recommended", e)
-            self.assertIsInstance(e.get("tags", []), list)
-
-
-class ApiTruthActionTest(unittest.TestCase):
-    def test_action_no_connection_needed(self):
-        # api_truth is dispatched before any _check — must work with no Resolve.
-        out = s.resolve_control("api_truth", {})
-        self.assertIn("verified_on", out)
-        self.assertEqual(out["count"], len(API_TRUTH))
-        self.assertTrue(out["facts"])
-
-    def test_action_query_filters(self):
-        out = s.resolve_control("api_truth", {"query": "fusion"})
-        self.assertTrue(out["count"] >= 1)
-        self.assertTrue(all("fusion" in (
-            e["symbol"] + e.get("object", "") + e["reality"] + " ".join(e.get("tags", []))
-        ).lower() for e in out["facts"]))
-
-
-if __name__ == "__main__":
-    unittest.main()