@hybridlabor-api/aos 4.3.0 → 4.4.1

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

@@ -1,302 +0,0 @@
-"""Unit tests for src/utils/embeddings.py (Phase C — embeddings + similarity).
-
-No Resolve and no embedding backends required: backend calls are mocked with
-deterministic keyword vectors, so these cover the store/search plumbing —
-v10 schema, idempotent builds, content-hash staleness, cosine ranking,
-self-exclusion, and the deep-field text builder.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import tempfile
-import unittest
-from unittest import mock
-
-from src.utils import analysis_store, embeddings, timeline_brain_db
-
-from tests.test_analysis_store import make_report
-
-_KEYWORDS = ("kenobi", "talks", "title", "closing")
-
-
-def fake_vector(text: str) -> list:
-    lowered = text.lower()
-    return [float(lowered.count(k)) for k in _KEYWORDS] + [1.0]
-
-
-def fake_embed_texts(texts, *, backend=None):
-    return {
-        "success": True,
-        "vectors": [fake_vector(t) for t in texts],
-        "model": "fake:test-embed",
-        "backend": "fake",
-    }
-
-
-class EmbeddingsBase(unittest.TestCase):
-    def setUp(self) -> None:
-        self.root = tempfile.mkdtemp(prefix="embeddings-test-")
-        self.addCleanup(shutil.rmtree, self.root, True)
-        self.addCleanup(timeline_brain_db.close_all)
-        result = analysis_store.ingest_report(self.root, make_report(), clip_dir="sample-clip-mp4-abcdef123456")
-        self.clip_uuid = result["clip_uuid"]
-
-
-class SchemaAndPackingTests(EmbeddingsBase):
-    def test_v10_embeddings_table_exists(self) -> None:
-        conn = timeline_brain_db.connect(self.root)
-        tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")}
-        self.assertIn("embeddings", tables)
-        self.assertGreaterEqual(timeline_brain_db._read_schema_version(conn), 10)
-
-    def test_pack_unpack_round_trip(self) -> None:
-        vec = [0.25, -1.5, 3.125, 0.0]
-        self.assertEqual(embeddings.unpack_vector(embeddings.pack_vector(vec)), vec)
-
-    def test_cosine_similarity(self) -> None:
-        self.assertAlmostEqual(embeddings.cosine_similarity([1, 0], [1, 0]), 1.0)
-        self.assertAlmostEqual(embeddings.cosine_similarity([1, 0], [0, 1]), 0.0)
-        self.assertEqual(embeddings.cosine_similarity([0, 0], [1, 1]), 0.0)
-
-    def test_detect_capabilities_shape(self) -> None:
-        caps = embeddings.detect_embedding_capabilities()
-        self.assertIn("text", caps)
-        self.assertIn("visual", caps)
-        self.assertTrue(caps["no_auto_install"])
-        if not caps["text"]["available"]:
-            self.assertIn("text", caps["install_guidance"])
-
-
-class BuildEmbeddingsTests(EmbeddingsBase):
-    def test_build_text_embeddings_and_idempotency(self) -> None:
-        with mock.patch.object(embeddings, "embed_texts", side_effect=fake_embed_texts):
-            first = embeddings.build_embeddings(self.root, kinds=("text",))
-            self.assertTrue(first["success"], first)
-            # 1 clip + 3 shots + 2 segments
-            self.assertEqual(first["text"]["embedded"], 6)
-            second = embeddings.build_embeddings(self.root, kinds=("text",))
-            self.assertEqual(second["text"]["embedded"], 0)
-        self.assertEqual(first["totals"]["text"], 6)
-
-    def test_content_change_triggers_reembed(self) -> None:
-        with mock.patch.object(embeddings, "embed_texts", side_effect=fake_embed_texts):
-            embeddings.build_embeddings(self.root, kinds=("text",))
-            analysis_store.record_human_correction(
-                self.root, clip_ref=self.clip_uuid, entity_type="shot", entity_uuid=2,
-                field_path="description", value="A corrected description.", author="sam",
-            )
-            # The shots table row text comes from ingest; re-ingest the exported
-            # report so the human description lands in the shots table.
-            exported = analysis_store.export_report(self.root, self.clip_uuid)
-            analysis_store.ingest_report(self.root, exported, clip_dir="sample-clip-mp4-abcdef123456")
-            result = embeddings.build_embeddings(self.root, kinds=("text",))
-            self.assertEqual(result["text"]["embedded"], 1)
-
-    def test_no_backend_fails_soft(self) -> None:
-        with mock.patch.object(
-            embeddings, "embed_texts",
-            return_value={"success": False, "error": "No text-embedding backend available"},
-        ):
-            result = embeddings.build_embeddings(self.root, kinds=("text",))
-        self.assertFalse(result["success"])
-        self.assertIn("error", result["text"])
-
-    def test_shot_embed_text_includes_deep_groups(self) -> None:
-        shot = {
-            "description": "Wide drive-by.",
-            "extra_json": json.dumps({
-                "visual": {"shot_size": "wide", "camera_motion": "handheld"},
-                "editorial": {"select_potential": "high"},
-            }),
-        }
-        text = embeddings._shot_embed_text(shot)
-        self.assertIn("Wide drive-by.", text)
-        self.assertIn("shot_size", text)
-        self.assertIn("select_potential", text)
-
-    def test_build_visual_embeddings_with_mock(self) -> None:
-        # Put fake frame files on disk and point the frames table at them.
-        frames_dir = os.path.join(self.root, "clips", "sample-clip-mp4-abcdef123456", "frames")
-        os.makedirs(frames_dir, exist_ok=True)
-        report = make_report()
-        for kf in report["motion"]["analysis_keyframes"]:
-            path = os.path.join(frames_dir, f"sampled_{kf['index']:04d}.jpg")
-            with open(path, "wb") as handle:
-                handle.write(b"fake")
-            kf["frame_path"] = path
-        analysis_store.ingest_report(self.root, report, clip_dir="sample-clip-mp4-abcdef123456")
-
-        def fake_embed_images(paths):
-            return {
-                "success": True,
-                "vectors": [[1.0, float(i)] for i, _ in enumerate(paths)],
-                "model": "fake:clip",
-            }
-
-        with mock.patch.object(embeddings, "embed_images", side_effect=fake_embed_images):
-            result = embeddings.build_embeddings(self.root, kinds=("visual",))
-        self.assertTrue(result["success"], result)
-        # 3 frames + 3 per-shot mean vectors (each shot has one frame).
-        self.assertEqual(result["visual"]["embedded"], 6)
-        conn = timeline_brain_db.connect(self.root)
-        kinds = conn.execute(
-            "SELECT entity_type, COUNT(*) AS n FROM embeddings WHERE embedding_kind='visual' GROUP BY entity_type"
-        ).fetchall()
-        counts = {r["entity_type"]: r["n"] for r in kinds}
-        self.assertEqual(counts, {"frame": 3, "shot": 3})
-
-
-class FindSimilarTests(EmbeddingsBase):
-    def setUp(self) -> None:
-        super().setUp()
-        with mock.patch.object(embeddings, "embed_texts", side_effect=fake_embed_texts):
-            embeddings.build_embeddings(self.root, kinds=("text",))
-
-    def test_text_query_ranks_matching_segment_first(self) -> None:
-        with mock.patch.object(embeddings, "embed_texts", side_effect=fake_embed_texts):
-            result = embeddings.find_similar(self.root, text="general kenobi", limit=3)
-        self.assertTrue(result["success"], result)
-        top = result["results"][0]
-        self.assertEqual(top["entity_type"], "segment")
-        self.assertIn("kenobi", top["text"])
-
-    def test_clip_query_excludes_itself(self) -> None:
-        result = embeddings.find_similar(self.root, clip_ref=self.clip_uuid, limit=10)
-        self.assertTrue(result["success"], result)
-        for hit in result["results"]:
-            self.assertFalse(
-                hit["entity_type"] == "clip" and hit["entity_uuid"] == self.clip_uuid,
-                "query entity leaked into its own results",
-            )
-
-    def test_shot_query_by_index(self) -> None:
-        result = embeddings.find_similar(self.root, clip_ref=self.clip_uuid, shot_index=2, limit=5)
-        self.assertTrue(result["success"], result)
-        self.assertTrue(result["results"])
-
-    def test_missing_embedding_says_build_first(self) -> None:
-        result = embeddings.find_similar(self.root, clip_ref=self.clip_uuid, kind="visual")
-        self.assertFalse(result["success"])
-        self.assertIn("build_embeddings", result["error"])
-
-    def test_entity_type_filter(self) -> None:
-        with mock.patch.object(embeddings, "embed_texts", side_effect=fake_embed_texts):
-            result = embeddings.find_similar(
-                self.root, text="talks", entity_types=["shot"], limit=10
-            )
-        self.assertTrue(result["success"])
-        self.assertTrue(all(r["entity_type"] == "shot" for r in result["results"]))
-
-
-def fake_embed_audio_windows(file_path, windows):
-    # One deterministic vector per window, keyed by the window start.
-    return {
-        "success": True,
-        "vectors": [[1.0, float(start), 0.5] for start, _end in windows],
-        "model": "fake:clap",
-    }
-
-
-class AudioEmbeddingsTests(EmbeddingsBase):
-    """CLAP audio embeddings (Phase 6) — backend mocked; covers the build
-    plumbing, graceful skip, missing media, and audio similarity search."""
-
-    def _ingest_with_real_media(self) -> str:
-        media = os.path.join(self.root, "fake-media.mp4")
-        with open(media, "wb") as handle:
-            handle.write(b"not really media")
-        report = make_report()
-        report["clip"] = dict(report["clip"], file_path=media)
-        result = analysis_store.ingest_report(self.root, report, clip_dir="sample-clip-mp4-abcdef123456")
-        return result["clip_uuid"]
-
-    def test_capabilities_include_audio_block(self) -> None:
-        caps = embeddings.detect_embedding_capabilities()
-        self.assertIn("audio", caps)
-        self.assertIn("backends", caps["audio"])
-        if not caps["audio"]["available"]:
-            self.assertIn("audio", caps["install_guidance"])
-
-    def test_build_audio_embeddings_and_idempotency(self) -> None:
-        clip_uuid = self._ingest_with_real_media()
-        available = {"audio": {"available": True, "backends": ["transformers_clap"],
-                               "model": "fake", "ffmpeg": True}, "install_guidance": {}}
-        with mock.patch.object(embeddings, "detect_embedding_capabilities", return_value=available), \
-             mock.patch.object(embeddings, "embed_audio_windows", side_effect=fake_embed_audio_windows):
-            first = embeddings.build_embeddings(self.root, kinds=("audio",))
-            self.assertTrue(first["success"], first)
-            # 3 shot windows + 1 clip-level mean vector.
-            self.assertEqual(first["audio"]["embedded"], 4)
-            second = embeddings.build_embeddings(self.root, kinds=("audio",))
-            self.assertEqual(second["audio"]["embedded"], 0)
-        conn = timeline_brain_db.connect(self.root)
-        counts = {
-            r["entity_type"]: r["n"] for r in conn.execute(
-                "SELECT entity_type, COUNT(*) AS n FROM embeddings "
-                "WHERE embedding_kind='audio' GROUP BY entity_type"
-            )
-        }
-        self.assertEqual(counts, {"shot": 3, "clip": 1})
-        row = conn.execute(
-            "SELECT vector FROM embeddings WHERE embedding_kind='audio' AND entity_type='clip' AND entity_uuid=?",
-            (clip_uuid,),
-        ).fetchone()
-        self.assertIsNotNone(row)
-
-    def test_build_audio_graceful_skip_without_backend(self) -> None:
-        self._ingest_with_real_media()
-        unavailable = {"audio": {"available": False, "backends": [], "model": None, "ffmpeg": True},
-                       "install_guidance": {"audio": "pip install transformers"}}
-        with mock.patch.object(embeddings, "detect_embedding_capabilities", return_value=unavailable):
-            result = embeddings.build_embeddings(self.root, kinds=("audio",))
-        self.assertFalse(result["success"])
-        self.assertTrue(result["audio"]["skipped"])
-        self.assertEqual(result["audio"]["install_guidance"], "pip install transformers")
-
-    def test_missing_media_is_reported_not_fatal(self) -> None:
-        # make_report's file_path (/media/sample clip.mp4) does not exist.
-        available = {"audio": {"available": True, "backends": ["transformers_clap"],
-                               "model": "fake", "ffmpeg": True}, "install_guidance": {}}
-        with mock.patch.object(embeddings, "detect_embedding_capabilities", return_value=available), \
-             mock.patch.object(embeddings, "embed_audio_windows", side_effect=fake_embed_audio_windows):
-            result = embeddings.build_embeddings(self.root, kinds=("audio",))
-        self.assertTrue(result["success"], result)
-        self.assertEqual(result["audio"]["embedded"], 0)
-        self.assertEqual(len(result["audio"]["skipped_missing_media"]), 1)
-
-    def test_find_similar_audio_by_shot_and_text(self) -> None:
-        media_clip_uuid = self._ingest_with_real_media()
-        available = {"audio": {"available": True, "backends": ["transformers_clap"],
-                               "model": "fake", "ffmpeg": True}, "install_guidance": {}}
-        with mock.patch.object(embeddings, "detect_embedding_capabilities", return_value=available), \
-             mock.patch.object(embeddings, "embed_audio_windows", side_effect=fake_embed_audio_windows):
-            embeddings.build_embeddings(self.root, kinds=("audio",))
-        result = embeddings.find_similar(
-            self.root, clip_ref=media_clip_uuid, shot_index=1, kind="audio", limit=5)
-        self.assertTrue(result["success"], result)
-        self.assertTrue(result["results"])
-        with mock.patch.object(
-            embeddings, "embed_text_for_audio_query",
-            return_value={"success": True, "vector": [1.0, 0.0, 0.5], "model": "fake:clap"},
-        ):
-            text_result = embeddings.find_similar(self.root, text="engine revving", kind="audio")
-        self.assertTrue(text_result["success"], text_result)
-        self.assertTrue(text_result["results"])
-
-    def test_find_similar_rejects_unknown_kind(self) -> None:
-        result = embeddings.find_similar(self.root, text="x", kind="smell")
-        self.assertFalse(result["success"])
-        self.assertIn("audio", result["error"])
-
-    def test_embed_audio_windows_requires_backend(self) -> None:
-        result = embeddings.embed_audio_windows("/no/such/file.mp4", [(0.0, 5.0)])
-        if not embeddings.detect_embedding_capabilities()["audio"]["available"]:
-            self.assertFalse(result["success"])
-            self.assertIn("install_guidance", result)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,225 +0,0 @@
-"""Unit tests for src/utils/entities.py (Phase D — cross-clip entities).
-
-No Resolve and no embedding backends required: visual vectors are written
-straight into the v10 embeddings table so clustering, the confirmation
-payload, commit (labels + merges), ghost pruning, and the bin-briefing flow
-are all covered offline.
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import shutil
-import tempfile
-import unittest
-from unittest import mock
-
-from src.utils import analysis_memory, analysis_store, embeddings, entities, timeline_brain_db
-from src.utils import media_analysis as ma
-
-from tests.test_analysis_store import make_report
-
-
-def _vec(direction: int, jitter: float = 0.0) -> list:
-    """Unit-ish vectors: same direction → cosine ~1, different → ~0."""
-    base = [0.0] * 8
-    base[direction] = 1.0
-    if jitter:
-        base[(direction + 1) % 8] = jitter
-    return base
-
-
-class EntitiesBase(unittest.TestCase):
-    def setUp(self) -> None:
-        self.root = tempfile.mkdtemp(prefix="entities-test-")
-        self.addCleanup(shutil.rmtree, self.root, True)
-        self.addCleanup(timeline_brain_db.close_all)
-        # Two clips so clusters can span clips.
-        report_a = make_report()
-        self.clip_a = analysis_store.ingest_report(self.root, report_a, clip_dir="clip-a-aaaaaaaaaaaa")["clip_uuid"]
-        report_b = make_report()
-        report_b["clip"] = dict(report_b["clip"], clip_id="22222222-0000-0000-0000-000000000002",
-                                clip_name="Second Clip.mp4", file_path="/media/second clip.mp4", media_id="cccc-dddd")
-        self.clip_b = analysis_store.ingest_report(self.root, report_b, clip_dir="second-clip-mp4-bbbbbbbbbbbb")["clip_uuid"]
-        self.frames_dir = os.path.join(self.root, "frames-fake")
-        os.makedirs(self.frames_dir, exist_ok=True)
-
-    def _add_visual_vector(self, clip_uuid: str, frame_index: int, vector: list) -> str:
-        ref = f"{clip_uuid}:{frame_index}"
-        path = os.path.join(self.frames_dir, f"{clip_uuid}_{frame_index}.jpg")
-        with open(path, "wb") as handle:
-            handle.write(b"fake")
-        conn = timeline_brain_db.connect(self.root)
-        with timeline_brain_db.transaction(self.root) as txn:
-            txn.execute(
-                "UPDATE frames SET frame_path = ? WHERE clip_uuid = ? AND frame_index = ?",
-                (path, clip_uuid, frame_index),
-            )
-            txn.execute(
-                """
-                INSERT OR REPLACE INTO embeddings
-                    (entity_type, entity_uuid, embedding_kind, model_name, dimension,
-                     vector, content_hash, computed_at)
-                VALUES ('frame', ?, 'visual', 'fake:clip', ?, ?, 'h', '2026-06-10T00:00:00Z')
-                """,
-                (ref, len(vector), embeddings.pack_vector(vector)),
-            )
-        return ref
-
-    def _seed_two_clusters(self) -> None:
-        # Cluster 1: same "person" in both clips (3 frames).
-        self._add_visual_vector(self.clip_a, 1, _vec(0))
-        self._add_visual_vector(self.clip_a, 2, _vec(0, 0.05))
-        self._add_visual_vector(self.clip_b, 1, _vec(0, 0.1))
-        # Cluster 2: a "location" in clip B (2 frames).
-        self._add_visual_vector(self.clip_b, 2, _vec(3))
-        self._add_visual_vector(self.clip_b, 3, _vec(3, 0.05))
-
-
-class DetectEntitiesTests(EntitiesBase):
-    def test_requires_visual_embeddings(self) -> None:
-        result = entities.detect_entities(self.root)
-        self.assertFalse(result["success"])
-        self.assertIn("build_embeddings", result["error"])
-
-    def test_clusters_and_payload(self) -> None:
-        self._seed_two_clusters()
-        result = entities.detect_entities(self.root)
-        self.assertTrue(result["success"], result)
-        self.assertEqual(result["status"], "pending_host_analysis")
-        self.assertEqual(result["cluster_count"], 2)
-        first = result["clusters"][0]
-        self.assertEqual(first["frame_count"], 3)
-        self.assertEqual(first["clip_count"], 2)  # spans both clips
-        self.assertEqual(len(result["frame_paths"]), 2)
-        self.assertEqual(result["commit_action"]["action"], "commit_entities")
-        # Provisional rows exist with appearances.
-        listed = entities.list_entities(self.root)
-        self.assertEqual(listed["count"], 2)
-        self.assertEqual(listed["entities"][0]["source"], "clustering")
-        self.assertEqual(listed["entities"][0]["clip_count"], 2)
-
-    def test_caps_refusal_blocks(self) -> None:
-        self._seed_two_clusters()
-        refusal = {"success": False, "error": "over_day_cap", "caps_refusal": True}
-        with mock.patch.object(ma, "_check_caps_pre_call", return_value=refusal):
-            result = entities.detect_entities(self.root)
-        self.assertEqual(result, refusal)
-
-    def test_rerun_prunes_unlabeled_ghosts_keeps_labeled(self) -> None:
-        self._seed_two_clusters()
-        payload = entities.detect_entities(self.root)
-        # Label cluster 1.
-        entities.commit_entities(
-            self.root,
-            entities_payload=[{"entity_index": 1, "kind": "person", "label": "man in dark jacket",
-                               "description": "recurring driver", "confidence": "medium"}],
-            vision_token=payload["vision_token"],
-        )
-        # Add a vector that reshapes cluster 2 (new uuid), re-detect.
-        self._add_visual_vector(self.clip_b, 2, _vec(3, 0.2))
-        entities.detect_entities(self.root)
-        listed = entities.list_entities(self.root)
-        labels = [e.get("label") for e in listed["entities"]]
-        self.assertIn("man in dark jacket", labels)
-        unlabeled = [e for e in listed["entities"] if not e.get("label")]
-        # Only current-run provisionals remain — no accumulated ghosts.
-        self.assertLessEqual(len(unlabeled), 1)
-
-
-class CommitEntitiesTests(EntitiesBase):
-    def test_commit_labels_and_merge(self) -> None:
-        self._seed_two_clusters()
-        payload = entities.detect_entities(self.root)
-        result = entities.commit_entities(
-            self.root,
-            entities_payload={"entities": [
-                {"entity_index": 1, "kind": "person", "label": "man in dark hooded jacket",
-                 "description": "Driver recurring across both clips.", "confidence": "high"},
-                {"entity_index": 2, "kind": "place", "label": "roadside location",
-                 "description": "Exterior road location.", "confidence": "medium"},
-            ]},
-            vision_token=payload["vision_token"],
-        )
-        self.assertTrue(result["success"], result)
-        self.assertEqual(result["entities_updated"], 2)
-        listed = entities.list_entities(self.root)
-        by_label = {e["label"]: e for e in listed["entities"]}
-        self.assertEqual(by_label["man in dark hooded jacket"]["kind"], "person")
-        self.assertEqual(by_label["man in dark hooded jacket"]["source"], "vision_entity_v1")
-
-    def test_merge_with_combines_clusters(self) -> None:
-        self._seed_two_clusters()
-        payload = entities.detect_entities(self.root)
-        result = entities.commit_entities(
-            self.root,
-            entities_payload=[
-                {"entity_index": 1, "kind": "person", "label": "driver", "confidence": "high"},
-                {"entity_index": 2, "merge_with": 1},
-            ],
-            vision_token=payload["vision_token"],
-        )
-        self.assertTrue(result["success"], result)
-        self.assertEqual(result["entities_merged"], 1)
-        listed = entities.list_entities(self.root)
-        self.assertEqual(listed["count"], 1)
-        self.assertEqual(listed["entities"][0]["cluster_size"], 5)
-
-    def test_token_mismatch_rejected(self) -> None:
-        self._seed_two_clusters()
-        entities.detect_entities(self.root)
-        result = entities.commit_entities(
-            self.root, entities_payload=[{"entity_index": 1, "label": "x"}], vision_token="bogus"
-        )
-        self.assertFalse(result["success"])
-        self.assertIn("vision_token mismatch", result["error"])
-
-
-class BinBriefingTests(EntitiesBase):
-    def test_prepare_and_commit_briefing(self) -> None:
-        self._seed_two_clusters()
-        payload = entities.detect_entities(self.root)
-        entities.commit_entities(
-            self.root,
-            entities_payload=[{"entity_index": 1, "kind": "person", "label": "driver", "confidence": "high"}],
-            vision_token=payload["vision_token"],
-        )
-        prep = entities.prepare_bin_briefing(self.root)
-        self.assertTrue(prep["success"], prep)
-        self.assertEqual(prep["status"], "pending_host_synthesis")
-        self.assertEqual(len(prep["clips"]), 2)
-        self.assertTrue(any(e["label"] == "driver" for e in prep["entities"]))
-
-        commit = entities.commit_bin_summary(
-            self.root,
-            briefing="Two clips of stunt-comedy coverage; the driver recurs throughout.",
-            briefing_token=prep["briefing_token"],
-        )
-        self.assertTrue(commit["success"], commit)
-        with open(analysis_memory.bin_summary_path(self.root), "r", encoding="utf-8") as handle:
-            content = handle.read()
-        self.assertIn("# Bin briefing", content)
-        self.assertIn("the driver recurs", content)
-
-    def test_briefing_preserves_aggregate_appendix(self) -> None:
-        path = analysis_memory.bin_summary_path(self.root)
-        analysis_memory.ensure_memory_structure(self.root)
-        with open(path, "w", encoding="utf-8") as handle:
-            handle.write("# Bin summary — Old Aggregate\n\naggregate body\n")
-        prep = entities.prepare_bin_briefing(self.root)
-        entities.commit_bin_summary(
-            self.root, briefing="New briefing.", briefing_token=prep["briefing_token"]
-        )
-        with open(path, "r", encoding="utf-8") as handle:
-            content = handle.read()
-        self.assertIn("New briefing.", content)
-        self.assertIn("# Bin summary — Old Aggregate", content)
-
-    def test_briefing_token_mismatch(self) -> None:
-        result = entities.commit_bin_summary(self.root, briefing="x", briefing_token="bogus")
-        self.assertFalse(result["success"])
-
-
-if __name__ == "__main__":
-    unittest.main()