@iseoane/agent-depot 0.2.0 → 0.3.0

package/skills/doctor-md-agents/scripts/test_scan_corrections.py

@@ -1,343 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for scan_corrections.py."""
-
-import json
-import os
-import tempfile
-import unittest
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-
-import scan_corrections as sc
-
-
-def write_jsonl(path, records):
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text("\n".join(json.dumps(r) for r in records) + "\n", encoding="utf-8")
-
-
-def run_scan(claude_home, out_dir, **kwargs):
-    argv = ["--out", str(out_dir), "--claude-home", str(claude_home),
-            "--codex-home", str(Path(out_dir) / "no-codex-here")]
-    for key, value in kwargs.items():
-        flag = "--" + key.replace("_", "-")
-        if value is True:
-            argv.append(flag)
-        elif value is False:
-            continue
-        else:
-            argv.extend([flag, str(value)])
-    sc.main(argv)
-    return json.loads((Path(out_dir) / "corrections.json").read_text())
-
-
-def now_iso(offset_days=0):
-    return (datetime.now(timezone.utc) - timedelta(days=offset_days)).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-class BreakingCaseTests(unittest.TestCase):
-    def test_tool_result_only_user_record_is_ignored(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            path = claude_home / "projects" / "p1" / "s1.jsonl"
-            write_jsonl(path, [
-                {"type": "user", "sessionId": "s1", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1",
-                 "message": {"role": "user", "content": [
-                     {"type": "tool_result", "content": "some tool output"}
-                 ]}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["user_turns"], 0)
-
-    def test_command_name_turn_is_ignored(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            path = claude_home / "projects" / "p1" / "s1.jsonl"
-            write_jsonl(path, [
-                {"type": "user", "sessionId": "s1", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1",
-                 "message": {"role": "user",
-                             "content": "<command-name>/clear</command-name>\nno uses npm nunca"}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["user_turns"], 0)
-            self.assertEqual(report["stats"]["corrections_found"], 0)
-
-    def test_sidechain_turn_is_ignored(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            path = claude_home / "projects" / "p1" / "s1.jsonl"
-            write_jsonl(path, [
-                {"type": "user", "sessionId": "s1", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1", "isSidechain": True,
-                 "message": {"role": "user", "content": "no uses npm, usa pnpm"}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["user_turns"], 0)
-
-    def test_same_session_id_across_two_files_counted_once(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            ts = now_iso()
-            record = {
-                "type": "user", "sessionId": "shared-session", "cwd": "/repo", "timestamp": ts,
-                "uuid": "same-uuid",
-                "message": {"role": "user", "content": "hello there, nothing special"},
-            }
-            write_jsonl(claude_home / "projects" / "p1" / "a.jsonl", [record])
-            write_jsonl(claude_home / "projects" / "p1" / "b.jsonl", [record])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["sessions_scanned"], 1)
-            self.assertEqual(report["stats"]["user_turns"], 1)
-
-    def test_real_correction_is_found_with_pattern_and_preceding_context(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            path = claude_home / "projects" / "p1" / "s1.jsonl"
-            write_jsonl(path, [
-                {"type": "assistant", "sessionId": "s1", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "a1",
-                 "message": {"role": "assistant", "id": "m1",
-                             "content": [{"type": "text", "text": "Installing with npm install."}]}},
-                {"type": "user", "sessionId": "s1", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1",
-                 "message": {"role": "user", "content": "no, usa pnpm no npm"}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(len(report["corrections"]), 1)
-            corr = report["corrections"][0]
-            self.assertEqual(corr["pattern"], "no, usa")
-            self.assertIn("pnpm", corr["text"])
-            self.assertIn("npm install", corr["preceding"])
-
-
-class WindowAndRepoTests(unittest.TestCase):
-    def test_days_excludes_old_session(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            path = claude_home / "projects" / "p1" / "old.jsonl"
-            old_ts = (datetime.now(timezone.utc) - timedelta(days=200)).strftime("%Y-%m-%dT%H:%M:%SZ")
-            write_jsonl(path, [
-                {"type": "user", "sessionId": "old-session", "cwd": "/repo", "timestamp": old_ts,
-                 "uuid": "u1", "message": {"role": "user", "content": "no uses npm nunca mas"}},
-            ])
-            old_time = (datetime.now(timezone.utc) - timedelta(days=200)).timestamp()
-            os.utime(path, (old_time, old_time))
-            report = run_scan(claude_home, Path(tmp) / "out", days=90, all_conversations=True)
-            self.assertEqual(report["stats"]["sessions_scanned"], 0)
-
-    def test_repo_filters_by_cwd(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            in_repo = Path(tmp) / "repo-a"
-            out_repo = Path(tmp) / "repo-b"
-            write_jsonl(claude_home / "projects" / "p1" / "s1.jsonl", [
-                {"type": "user", "sessionId": "s-in", "cwd": str(in_repo), "timestamp": now_iso(),
-                 "uuid": "u1", "message": {"role": "user", "content": "hi there in repo a"}},
-            ])
-            write_jsonl(claude_home / "projects" / "p1" / "s2.jsonl", [
-                {"type": "user", "sessionId": "s-out", "cwd": str(out_repo), "timestamp": now_iso(),
-                 "uuid": "u2", "message": {"role": "user", "content": "hi there in repo b"}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", repo=str(in_repo))
-            self.assertEqual(report["stats"]["sessions_in_scope"], 1)
-            self.assertEqual(report["stats"]["sessions_scanned"], 2)
-
-
-class ClusteringTests(unittest.TestCase):
-    def test_shared_salient_tokens_form_a_cluster(self):
-        corrections = [
-            {"session_id": "s1", "text": "no uses npm, usa siempre pnpm para el frontend"},
-            {"session_id": "s2", "text": "otra vez con npm, usa pnpm en el frontend por favor"},
-            {"session_id": "s3", "text": "cosa totalmente distinta sobre bandas LTE"},
-        ]
-        clusters = sc.build_clusters(corrections)
-        big = next(c for c in clusters if c["count"] == 2)
-        self.assertEqual(set(big["sessions"]), {"s1", "s2"})
-        singleton = next(c for c in clusters if c["count"] == 1)
-        self.assertEqual(singleton["sessions"], ["s3"])
-
-    def test_clusters_sorted_by_count_descending(self):
-        corrections = [
-            {"session_id": "s1", "text": "pnpm frontend siempre pnpm"},
-            {"session_id": "s2", "text": "pnpm frontend siempre pnpm otra vez"},
-            {"session_id": "s3", "text": "algo distinto"},
-        ]
-        clusters = sc.build_clusters(corrections)
-        counts = [c["count"] for c in clusters]
-        self.assertEqual(counts, sorted(counts, reverse=True))
-
-
-class MachineTurnFilterTests(unittest.TestCase):
-    def test_long_turn_matching_pattern_is_dropped_as_too_long(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            long_text = "no, usa pnpm en vez de npm. " + ("relleno de plantilla " * 100)
-            self.assertGreater(len(long_text), 1200)
-            path = claude_home / "projects" / "p1" / "s1.jsonl"
-            write_jsonl(path, [
-                {"type": "user", "sessionId": "s1", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1", "message": {"role": "user", "content": long_text}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["corrections_found"], 0)
-            self.assertEqual(report["stats"]["turns_dropped_too_long"], 1)
-            # Still counted as a real, in-scope user turn -- the arithmetic
-            # user_turns - turns_dropped_too_long stays auditable.
-            self.assertEqual(report["stats"]["user_turns"], 1)
-
-    def test_short_text_in_three_distinct_sessions_is_dropped_as_template(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            template_text = "no uses npm, usa siempre pnpm en el frontend"
-            for i in range(3):
-                path = claude_home / "projects" / "p1" / f"s{i}.jsonl"
-                write_jsonl(path, [
-                    {"type": "user", "sessionId": f"tmpl-{i}", "cwd": "/repo", "timestamp": now_iso(),
-                     "uuid": "u1", "message": {"role": "user", "content": template_text}},
-                ])
-            genuine_path = claude_home / "projects" / "p1" / "genuine.jsonl"
-            write_jsonl(genuine_path, [
-                {"type": "user", "sessionId": "genuine-session", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1",
-                 "message": {"role": "user", "content": "no, usa argon2 en vez de bcrypt para el hashing"}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["turns_dropped_templated"], 3)
-            self.assertEqual(report["stats"]["corrections_found"], 1)
-            self.assertIn("argon2", report["corrections"][0]["text"])
-            self.assertEqual(len(report["dropped_templates"]), 1)
-            self.assertEqual(report["dropped_templates"][0]["sessions"], 3)
-            self.assertEqual(report["dropped_templates"][0]["occurrences"], 3)
-            self.assertIn("no uses npm", report["dropped_templates"][0]["prefix"])
-
-    def test_same_text_repeated_in_one_session_is_not_templated(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            text = "no uses npm, usa siempre pnpm en el frontend"
-            path = claude_home / "projects" / "p1" / "s1.jsonl"
-            records = [
-                {"type": "user", "sessionId": "one-session", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": f"u{i}", "message": {"role": "user", "content": text}}
-                for i in range(3)
-            ]
-            write_jsonl(path, records)
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["turns_dropped_templated"], 0)
-            self.assertEqual(report["stats"]["corrections_found"], 3)
-            self.assertEqual(report["dropped_templates"], [])
-
-    def test_short_prefix_key_catches_templates_with_diverging_payloads(self):
-        # Pins the real-world failure: a machine template's grouping key
-        # must be its opening, not a suffix that reaches into a variable
-        # payload (an id, a JSON blob) -- otherwise every instance hashes
-        # differently and the template filter never fires on exactly the
-        # turns it exists to catch.
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            shared_opening = (
-                "no, usa siempre el snapshot inmutable del commit para intentar refutar el "
-                "hallazgo critico representado como JSON no confiable a continuacion, sin "
-                "modificar el arbol de commits objetivo bajo ninguna circunstancia: "
-            )
-            self.assertGreaterEqual(len(shared_opening), 160)
-            payloads = [
-                '{"finding_id": "aaaa-1111", "severity": "critical", "path": "/repo/a.py"}',
-                '{"finding_id": "bbbb-2222", "severity": "critical", "path": "/repo/b.py"}',
-                '{"finding_id": "cccc-3333", "severity": "critical", "path": "/repo/c.py"}',
-            ]
-            for i, payload in enumerate(payloads):
-                text = shared_opening + payload
-                self.assertLess(len(text), 1200)
-                path = claude_home / "projects" / "p1" / f"s{i}.jsonl"
-                write_jsonl(path, [
-                    {"type": "user", "sessionId": f"refuter-{i}", "cwd": "/repo", "timestamp": now_iso(),
-                     "uuid": "u1", "message": {"role": "user", "content": text}},
-                ])
-
-            # Default --template-prefix-chars (160) keys on the shared
-            # opening alone: all three collapse into one template and are
-            # dropped, even though each turn's JSON payload is unique.
-            report = run_scan(claude_home, Path(tmp) / "out-default", all_conversations=True)
-            self.assertEqual(report["stats"]["turns_dropped_templated"], 3)
-            self.assertEqual(report["stats"]["corrections_found"], 0)
-            self.assertEqual(len(report["dropped_templates"]), 1)
-            self.assertEqual(report["dropped_templates"][0]["sessions"], 3)
-            self.assertEqual(report["dropped_templates"][0]["occurrences"], 3)
-
-            # A key long enough to reach into the payload (the pre-fix
-            # 300-char default) defeats the filter: each turn's key is
-            # unique because the whole (287-char) turn -- payload included
-            # -- becomes the key, so nothing repeats and nothing is dropped.
-            report_wide = run_scan(claude_home, Path(tmp) / "out-wide", all_conversations=True,
-                                    template_prefix_chars=300)
-            self.assertEqual(report_wide["stats"]["turns_dropped_templated"], 0)
-            self.assertEqual(report_wide["stats"]["corrections_found"], 3)
-
-    def test_custom_thresholds_are_honored(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            text = "no uses npm, usa siempre pnpm en el frontend"
-            for i in range(2):
-                path = claude_home / "projects" / "p1" / f"s{i}.jsonl"
-                write_jsonl(path, [
-                    {"type": "user", "sessionId": f"pair-{i}", "cwd": "/repo", "timestamp": now_iso(),
-                     "uuid": "u1", "message": {"role": "user", "content": text}},
-                ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True,
-                               template_threshold=2)
-            self.assertEqual(report["stats"]["turns_dropped_templated"], 2)
-            self.assertEqual(report["stats"]["corrections_found"], 0)
-
-
-class SelfSessionSentinelTests(unittest.TestCase):
-    def test_sentinel_turn_drops_the_whole_session(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            path = claude_home / "projects" / "p1" / "s1.jsonl"
-            write_jsonl(path, [
-                {"type": "user", "sessionId": "self-session", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1",
-                 "message": {"role": "user",
-                             "content": sc.SELF_SESSION_SENTINEL + "\njudge this transcript against rule X"}},
-                {"type": "user", "sessionId": "self-session", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u2", "message": {"role": "user", "content": "no, usa pnpm no npm"}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["sessions_skipped_self_session"], 1)
-            self.assertEqual(report["stats"]["turns_dropped_self_session"], 2)
-            self.assertEqual(report["stats"]["corrections_found"], 0)
-            self.assertEqual(report["corrections"], [])
-
-    def test_sentinel_does_not_affect_other_sessions(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            self_path = claude_home / "projects" / "p1" / "self.jsonl"
-            write_jsonl(self_path, [
-                {"type": "user", "sessionId": "self-session", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1", "message": {"role": "user", "content": sc.SELF_SESSION_SENTINEL}},
-            ])
-            real_path = claude_home / "projects" / "p1" / "real.jsonl"
-            write_jsonl(real_path, [
-                {"type": "user", "sessionId": "real-session", "cwd": "/repo", "timestamp": now_iso(),
-                 "uuid": "u1", "message": {"role": "user", "content": "no, usa pnpm no npm"}},
-            ])
-            report = run_scan(claude_home, Path(tmp) / "out", all_conversations=True)
-            self.assertEqual(report["stats"]["sessions_skipped_self_session"], 1)
-            self.assertEqual(len(report["corrections"]), 1)
-            self.assertEqual(report["corrections"][0]["session_id"], "real-session")
-
-
-class PatternMatchingTests(unittest.TestCase):
-    def test_curly_apostrophe_matches(self):
-        text = "don’t use npm here"
-        self.assertEqual(sc.first_match(sc.compile_patterns(None), text), "don't use")
-
-    def test_codex_injected_agents_md_is_filtered(self):
-        text = "# AGENTS.md instructions for /repo\n\n<INSTRUCTIONS>\nnunca hagas esto\n</INSTRUCTIONS>"
-        self.assertTrue(sc.looks_injected_codex(text))
-
-
-if __name__ == "__main__":
-    unittest.main()

package/skills/doctor-md-agents/scripts/test_verify_citations.py

@@ -1,236 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for verify_citations.py."""
-
-import json
-import tempfile
-import unittest
-from pathlib import Path
-from unittest import mock
-
-import verify_citations as vc
-
-
-def write_transcript(path, text):
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(text, encoding="utf-8")
-
-
-def write_findings(path, findings):
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps({"findings": findings}), encoding="utf-8")
-
-
-def run_verify(findings_path, out_dir, **kwargs):
-    argv = [str(findings_path), "--out", str(out_dir)]
-    for key, value in kwargs.items():
-        argv.extend([f"--{key.replace('_', '-')}", str(value)])
-    vc.main(argv)
-    return json.loads((Path(out_dir) / "findings.verified.json").read_text())
-
-
-class WhitespaceFoldingTests(unittest.TestCase):
-    def test_quote_matching_only_after_whitespace_folding_verifies(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "t1.md"
-            write_transcript(
-                transcript,
-                "[user] Please remember:   always   use pnpm\nfor  the  frontend  build.\n",
-            )
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "violated",
-                 "class": "non-compliance", "quote": "always use pnpm\n   for the   frontend build.",
-                 "reason": "the rule was ignored", "session_id": "s1"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            self.assertTrue(report["findings"][0]["verified"])
-            self.assertIsNone(report["findings"][0]["reason_code"])
-
-    def test_paraphrase_does_not_verify(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "t1.md"
-            write_transcript(transcript, "[user] Reminder: always use pnpm for the frontend build.\n")
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "violated",
-                 "class": "non-compliance",
-                 "quote": "the agent should always prefer pnpm instead of npm here",
-                 "reason": "paraphrased, not quoted", "session_id": "s1"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            self.assertFalse(report["findings"][0]["verified"])
-            self.assertEqual(report["findings"][0]["reason_code"], "not_found")
-
-    def test_case_difference_does_not_verify(self):
-        # Explicit assertion that the check is case-sensitive by design.
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "t1.md"
-            write_transcript(transcript, "[user] reminder: always use pnpm here for the build.\n")
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "violated",
-                 "class": "non-compliance", "quote": "ALWAYS USE PNPM HERE",
-                 "reason": "case differs from transcript", "session_id": "s1"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            finding = report["findings"][0]
-            self.assertFalse(finding["verified"])
-            self.assertEqual(finding["reason_code"], "not_found")
-            # Prove the ONLY thing wrong is case: the lowercase form does verify.
-            self.assertIn(
-                vc.fold_whitespace("always use pnpm here"),
-                vc.fold_whitespace(transcript.read_text(encoding="utf-8")),
-            )
-
-
-class ReasonCodeTests(unittest.TestCase):
-    def test_too_short_quote_gets_its_own_code(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "t1.md"
-            write_transcript(transcript, "[user] Always use pnpm here.\n")
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "followed",
-                 "class": "none", "quote": "pnpm", "reason": "too short to prove anything",
-                 "session_id": "s1"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            finding = report["findings"][0]
-            self.assertFalse(finding["verified"])
-            self.assertEqual(finding["reason_code"], "quote_too_short")
-
-    def test_missing_quote_field_gets_quote_missing(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "t1.md"
-            write_transcript(transcript, "[user] Always use pnpm here for the frontend.\n")
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "followed",
-                 "class": "none", "quote": "", "reason": "no citation given", "session_id": "s1"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            self.assertEqual(report["findings"][0]["reason_code"], "quote_missing")
-
-    def test_missing_transcript_yields_transcript_unreadable_not_not_found(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            missing_transcript = tmp / "does-not-exist.md"
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(missing_transcript), "label": "violated",
-                 "class": "non-compliance", "quote": "always use pnpm here for the build",
-                 "reason": "transcript file is gone", "session_id": "s1"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            finding = report["findings"][0]
-            self.assertFalse(finding["verified"])
-            self.assertEqual(finding["reason_code"], "transcript_unreadable")
-            self.assertEqual(report["stats"]["by_reason_code"]["transcript_unreadable"], 1)
-            self.assertEqual(report["stats"]["by_reason_code"]["not_found"], 0)
-
-
-class CachingTests(unittest.TestCase):
-    def test_shared_transcript_is_read_from_disk_once(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "shared.md"
-            write_transcript(transcript, "[user] Always use pnpm for the frontend build, please.\n")
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "followed",
-                 "class": "none", "quote": "Always use pnpm for the frontend build",
-                 "reason": "first citation", "session_id": "s1"},
-                {"rule_id": "r2", "transcript_path": str(transcript), "label": "violated",
-                 "class": "non-compliance", "quote": "for the frontend build, please",
-                 "reason": "second citation, same transcript", "session_id": "s1"},
-            ])
-            with mock.patch.object(vc, "load_transcript_text", wraps=vc.load_transcript_text) as spy:
-                report = run_verify(findings_path, tmp / "out")
-            self.assertEqual(spy.call_count, 1)
-            self.assertTrue(all(f["verified"] for f in report["findings"]))
-            self.assertEqual(report["stats"]["by_transcript"][str(transcript)]["total"], 2)
-
-
-class OptionalTriggerFieldTests(unittest.TestCase):
-    """scorers/adherence.md gains an optional `trigger` field per finding
-    (what the session was doing when the rule applied -- structure.md's raw
-    material for writing a condition). verify_citations.py does not verify
-    it like `quote`; it must pass it through untouched."""
-
-    def test_trigger_field_passes_through_unverified_and_unchanged(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "t1.md"
-            write_transcript(transcript, "[assistant] edited backend/analysis/parser_4g.py\n")
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "followed",
-                 "class": "none", "quote": "edited backend/analysis/parser_4g.py",
-                 "reason": "followed the rule while touching that file",
-                 "trigger": "editing backend/analysis/parser_4g.py"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            self.assertEqual(len(report["findings"]), 1)
-            finding = report["findings"][0]
-            self.assertTrue(finding["verified"])
-            self.assertEqual(finding["trigger"], "editing backend/analysis/parser_4g.py")
-
-    def test_finding_without_trigger_field_still_verifies(self):
-        # trigger is optional -- its absence must not change anything.
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            transcript = tmp / "t1.md"
-            write_transcript(transcript, "[assistant] ran pnpm install\n")
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(transcript), "label": "followed",
-                 "class": "none", "quote": "ran pnpm install", "reason": "used pnpm"},
-            ])
-            report = run_verify(findings_path, tmp / "out")
-            self.assertTrue(report["findings"][0]["verified"])
-            self.assertNotIn("trigger", report["findings"][0])
-
-
-class MalformedInputTests(unittest.TestCase):
-    def test_invalid_json_exits_non_zero(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            findings_path = tmp / "findings.json"
-            findings_path.write_text("{not json", encoding="utf-8")
-            with self.assertRaises(SystemExit) as ctx:
-                vc.main([str(findings_path), "--out", str(tmp / "out")])
-            self.assertNotEqual(ctx.exception.code, 0)
-
-    def test_missing_findings_key_exits_non_zero(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            findings_path = tmp / "findings.json"
-            findings_path.write_text(json.dumps({"nope": []}), encoding="utf-8")
-            with self.assertRaises(SystemExit) as ctx:
-                vc.main([str(findings_path), "--out", str(tmp / "out")])
-            self.assertNotEqual(ctx.exception.code, 0)
-
-    def test_verification_failures_still_exit_zero(self):
-        # Failing verification is data, not a script error -- main() must
-        # not raise SystemExit at all on a structurally valid input file.
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            findings_path = tmp / "findings.json"
-            write_findings(findings_path, [
-                {"rule_id": "r1", "transcript_path": str(tmp / "missing.md"), "label": "violated",
-                 "class": "non-compliance", "quote": "this quote will not verify at all",
-                 "reason": "bad citation", "session_id": "s1"},
-            ])
-            try:
-                vc.main([str(findings_path), "--out", str(tmp / "out")])
-            except SystemExit as exc:
-                self.fail(f"main() exited with {exc.code} on a merely-unverified finding")
-
-
-if __name__ == "__main__":
-    unittest.main()