@iseoane/agent-depot 0.2.0 → 0.3.0

package/skills/doctor-md-skill/scripts/test_detect_machine_sessions.py

@@ -1,181 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for detect_machine_sessions.py."""
-
-import json
-import tempfile
-import unittest
-from datetime import datetime, timezone
-from pathlib import Path
-
-import detect_machine_sessions as dms
-
-
-def now_iso():
-    return datetime.now(timezone.utc).isoformat()
-
-
-def write_claude_session(claude_home, project, session_id, user_texts, extra_record=None):
-    """Write a minimal Claude Code JSONL session with one user turn per
-    entry in `user_texts`, each followed by a matching assistant reply so
-    the session looks like a normal back-and-forth."""
-    project_dir = Path(claude_home) / "projects" / project
-    project_dir.mkdir(parents=True, exist_ok=True)
-    path = project_dir / f"{session_id}.jsonl"
-    lines = []
-    for text in user_texts:
-        lines.append({
-            "type": "user", "sessionId": session_id, "cwd": "/repo", "timestamp": now_iso(),
-            "message": {"role": "user", "content": [{"type": "text", "text": text}]},
-        })
-        lines.append({
-            "type": "assistant", "sessionId": session_id, "cwd": "/repo", "timestamp": now_iso(),
-            "message": {"role": "assistant", "id": f"{session_id}-{len(lines)}",
-                        "content": [{"type": "text", "text": "ok, working on it"}]},
-        })
-    if extra_record:
-        lines.append(extra_record)
-    path.write_text("\n".join(json.dumps(line) for line in lines), encoding="utf-8")
-    return path
-
-
-class LongFirstTurnTests(unittest.TestCase):
-    def test_long_first_turn_is_flagged(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            write_claude_session(claude_home, "proj", "s-long", ["x" * 5000])
-
-            records = dms.collect_candidates(
-                {"claude_home": claude_home, "codex_home": Path(tmp) / "nope",
-                 "pi_home": Path(tmp) / "nope", "grok_home": Path(tmp) / "nope",
-                 "zcode_home": Path(tmp) / "nope"},
-                datetime.now(timezone.utc).replace(year=2000),
-            )
-            flagged, _templates, stats = dms.flag_sessions(records, 1200, 3, 160)
-
-            self.assertEqual(stats["flagged_long_first_turn"], 1)
-            keys = [f["session_key"] for f in flagged]
-            self.assertIn("claude:s-long", keys)
-            entry = next(f for f in flagged if f["session_key"] == "claude:s-long")
-            self.assertIn("long_first_turn", entry["reasons"])
-
-    def test_short_first_turn_is_not_flagged(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            write_claude_session(claude_home, "proj", "s-short", ["please fix the login bug"])
-
-            records = dms.collect_candidates(
-                {"claude_home": claude_home, "codex_home": Path(tmp) / "nope",
-                 "pi_home": Path(tmp) / "nope", "grok_home": Path(tmp) / "nope",
-                 "zcode_home": Path(tmp) / "nope"},
-                datetime.now(timezone.utc).replace(year=2000),
-            )
-            flagged, _templates, _stats = dms.flag_sessions(records, 1200, 3, 160)
-
-            self.assertEqual(flagged, [])
-
-
-class TemplateDetectionTests(unittest.TestCase):
-    def test_same_prefix_in_three_distinct_sessions_is_flagged_as_template(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            template_text = "Score this transcript against the efficiency rubric and report a label."
-            for i in range(3):
-                write_claude_session(claude_home, "proj", f"s{i}", [template_text])
-            write_claude_session(claude_home, "proj", "s-oneoff", ["completely unrelated one-off request"])
-
-            records = dms.collect_candidates(
-                {"claude_home": claude_home, "codex_home": Path(tmp) / "nope",
-                 "pi_home": Path(tmp) / "nope", "grok_home": Path(tmp) / "nope",
-                 "zcode_home": Path(tmp) / "nope"},
-                datetime.now(timezone.utc).replace(year=2000),
-            )
-            flagged, dropped_templates, stats = dms.flag_sessions(records, 1200, 3, 160)
-
-            self.assertEqual(stats["flagged_templated"], 3)
-            flagged_keys = {f["session_key"] for f in flagged}
-            self.assertEqual(flagged_keys, {"claude:s0", "claude:s1", "claude:s2"})
-            self.assertNotIn("claude:s-oneoff", flagged_keys)
-            self.assertEqual(len(dropped_templates), 1)
-            self.assertEqual(dropped_templates[0]["sessions"], 3)
-
-    def test_same_text_repeated_in_one_session_is_not_a_template(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            repeated = "please continue with the next step"
-            write_claude_session(claude_home, "proj", "s-repeat", [repeated, repeated, repeated])
-
-            records = dms.collect_candidates(
-                {"claude_home": claude_home, "codex_home": Path(tmp) / "nope",
-                 "pi_home": Path(tmp) / "nope", "grok_home": Path(tmp) / "nope",
-                 "zcode_home": Path(tmp) / "nope"},
-                datetime.now(timezone.utc).replace(year=2000),
-            )
-            flagged, dropped_templates, stats = dms.flag_sessions(records, 1200, 3, 160)
-
-            self.assertEqual(stats["flagged_templated"], 0)
-            self.assertEqual(dropped_templates, [])
-            self.assertEqual(flagged, [])
-
-
-class SentinelTests(unittest.TestCase):
-    def test_session_carrying_sentinel_is_flagged(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            write_claude_session(
-                claude_home, "proj", "s-self",
-                [dms.MACHINE_SESSION_SENTINEL + "\nScore this transcript."],
-            )
-
-            records = dms.collect_candidates(
-                {"claude_home": claude_home, "codex_home": Path(tmp) / "nope",
-                 "pi_home": Path(tmp) / "nope", "grok_home": Path(tmp) / "nope",
-                 "zcode_home": Path(tmp) / "nope"},
-                datetime.now(timezone.utc).replace(year=2000),
-            )
-            flagged, _templates, stats = dms.flag_sessions(records, 1200, 3, 160)
-
-            self.assertEqual(stats["flagged_self_session_sentinel"], 1)
-            entry = next(f for f in flagged if f["session_key"] == "claude:s-self")
-            self.assertIn("self_session_sentinel", entry["reasons"])
-
-    def test_session_without_sentinel_is_not_flagged_for_it(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            write_claude_session(claude_home, "proj", "s-normal", ["a perfectly normal human request"])
-
-            records = dms.collect_candidates(
-                {"claude_home": claude_home, "codex_home": Path(tmp) / "nope",
-                 "pi_home": Path(tmp) / "nope", "grok_home": Path(tmp) / "nope",
-                 "zcode_home": Path(tmp) / "nope"},
-                datetime.now(timezone.utc).replace(year=2000),
-            )
-            flagged, _templates, stats = dms.flag_sessions(records, 1200, 3, 160)
-
-            self.assertEqual(stats["flagged_self_session_sentinel"], 0)
-            self.assertEqual(flagged, [])
-
-
-class CliTests(unittest.TestCase):
-    def test_main_writes_machine_sessions_json(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            claude_home = Path(tmp) / "claude"
-            write_claude_session(claude_home, "proj", "s-long", ["y" * 3000])
-            out_dir = Path(tmp) / "out"
-
-            dms.main([
-                "--out", str(out_dir),
-                "--claude-home", str(claude_home),
-                "--codex-home", str(Path(tmp) / "nope"),
-                "--pi-home", str(Path(tmp) / "nope"),
-                "--grok-home", str(Path(tmp) / "nope"),
-                "--zcode-home", str(Path(tmp) / "nope"),
-            ])
-
-            report = json.loads((out_dir / "machine_sessions.json").read_text())
-            self.assertEqual(report["stats"]["sessions_scanned"], 1)
-            self.assertEqual(report["stats"]["sessions_flagged"], 1)
-            self.assertEqual(report["sentinel"], dms.MACHINE_SESSION_SENTINEL)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/skills/doctor-md-skill/scripts/test_render_report.py

@@ -1,241 +0,0 @@
-#!/usr/bin/env python3
-"""Tests for doctor-md-skill report rendering."""
-
-import unittest
-from pathlib import Path
-from unittest.mock import patch
-
-from render_report import (
-    embedded_diffs_script,
-    format_generated_at,
-    open_report,
-    parse_args,
-    render_page,
-)
-
-
-class ReportRendererTests(unittest.TestCase):
-    def test_skill_startup_contract_is_centralized(self):
-        skill_root = Path(__file__).resolve().parent.parent
-        skill_text = (skill_root / "SKILL.md").read_text()
-        harness_text = (
-            skill_root / "references" / "supported-harnesses.md"
-        ).read_text()
-
-        self.assertIn(
-            "$SKILL_ROOT/references/supported-harnesses.md",
-            skill_text,
-        )
-        self.assertIn("Conversations in this repository", skill_text)
-        self.assertIn("All conversations", skill_text)
-        self.assertIn("Choose projects to analyze", skill_text)
-        self.assertIn(
-            "Project skills + global skills",
-            skill_text,
-        )
-        self.assertIn("Project skills only", skill_text)
-        self.assertIn(
-            "Process datasets of 50 transcripts or fewer in a single batch",
-            skill_text,
-        )
-        self.assertIn(
-            "For datasets with more than 50 transcripts, use parallel batches "
-            "(20 transcripts per batch recommended)",
-            skill_text,
-        )
-        self.assertNotIn("--claude-home PATH", skill_text)
-        self.assertIn("| Claude Code | `claude` |", harness_text)
-        self.assertIn("| Codex | `codex` |", harness_text)
-        self.assertIn("stop before creating a report directory", harness_text)
-
-    def test_code_diffs_follow_os_theme(self):
-        bundle = embedded_diffs_script()
-
-        self.assertIn('themeType:"system"', bundle)
-        self.assertIn(
-            'theme:{dark:"pierre-dark",light:"pierre-light"}',
-            bundle,
-        )
-
-    def test_report_follows_os_theme(self):
-        page = render_page({
-            "scores": {
-                "efficiency": 1.0,
-                "code_quality": 1.0,
-                "skill_coverage": 1.0,
-                "overall": 1.0,
-            },
-        })
-
-        self.assertIn('<meta name="color-scheme" content="light dark">', page)
-        self.assertIn("@media (prefers-color-scheme: dark)", page)
-        self.assertIn("--page-bg: #0f0d14", page)
-        self.assertIn("background: var(--surface)", page)
-        self.assertIn(
-            "--mono-font: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
-            page,
-        )
-        self.assertIn("--diffs-font-family: var(--mono-font)", page)
-        self.assertIn("--diffs-header-font-family: var(--mono-font)", page)
-
-    def test_report_carries_no_product_advertising(self):
-        report = {
-            "title": "Agent Skill Report",
-            "generated_at": "2026-08-25T00:00:00Z",
-            "harness": "codex",
-            "handle": "example",
-            "stats": {
-                "sessions_analyzed": 1,
-                "sessions_scanned": 1,
-                "skills_found": 1,
-                "skills_used": 1,
-                "window_days": 45,
-            },
-            "scores": {
-                "efficiency": 1.0,
-                "code_quality": 1.0,
-                "skill_coverage": 1.0,
-                "overall": 1.0,
-            },
-            "top_findings": ["No material waste detected."],
-            "suggestions": [],
-        }
-
-        page = render_page(report)
-
-        self.assertNotIn("factories-footer", page)
-        self.assertNotIn("Request access", page)
-        self.assertNotIn("cta_url", page)
-        self.assertIn(">Share</button>", page)
-        self.assertNotIn("all analysis ran locally", page)
-        self.assertIn(
-            "Generated August 25, 2026 at 12:00 AM UTC &middot; harness: codex",
-            page,
-        )
-
-    def test_generated_timestamp_formatting(self):
-        self.assertEqual(
-            format_generated_at("2026-08-27T22:06:10.421941+00"),
-            "August 27, 2026 at 10:06 PM UTC",
-        )
-        self.assertEqual(format_generated_at("not-a-date"), "not-a-date")
-
-    def test_open_report_uses_default_browser_with_file_uri(self):
-        report_path = Path("/tmp/skill doctor/report.html")
-        args = parse_args([str(report_path), "--open"])
-
-        self.assertEqual(args.report_path, str(report_path))
-        self.assertTrue(args.open_browser)
-
-        with patch("render_report.webbrowser.open", return_value=True) as browser_open:
-            self.assertTrue(open_report(report_path))
-
-        browser_open.assert_called_once_with(
-            report_path.absolute().as_uri(),
-            new=2,
-        )
-
-        with patch("render_report.webbrowser.open", side_effect=OSError):
-            self.assertFalse(open_report(report_path))
-
-    def test_share_card_uses_doctor_md_skill_attribution(self):
-        page = render_page({
-            "scores": {
-                "efficiency": 1.0,
-                "code_quality": 1.0,
-                "skill_coverage": 1.0,
-                "overall": 1.0,
-            },
-        })
-
-        self.assertIn(
-            '"stamp": ["Generated with doctor-md-skill", '
-            '"local run"]',
-            page,
-        )
-        self.assertIn('"eyebrow": "doctor-md-skill"', page)
-        self.assertIn("text('# ' + CARD.eyebrow", page)
-
-    def test_report_metric_lines_animate_like_skill_doctor_landing_page(self):
-        page = render_page({
-            "scores": {
-                "efficiency": 0.75,
-                "code_quality": 0.93,
-                "skill_coverage": 0.74,
-                "overall": 0.82,
-            },
-        })
-
-        self.assertIn(
-            "animation: report-fill 700ms "
-            "cubic-bezier(0.22, 1, 0.36, 1) var(--metric-delay) both",
-            page,
-        )
-        self.assertIn("@keyframes report-fill", page)
-        self.assertIn("from { transform: scaleX(0); }", page)
-        self.assertIn("to { transform: scaleX(1); }", page)
-        self.assertIn("width:75%;--metric-delay:180ms", page)
-        self.assertIn("width:93%;--metric-delay:290ms", page)
-        self.assertIn("width:74%;--metric-delay:400ms", page)
-        self.assertIn("@media (prefers-reduced-motion: reduce)", page)
-        self.assertIn(".bar-fill { animation: none; }", page)
-
-    def test_skill_output_uses_report_path_only(self):
-        skill_path = Path(__file__).resolve().parent.parent / "SKILL.md"
-        skill_text = skill_path.read_text()
-
-        self.assertIn(
-            'render_report.py" "$REPORT_DIR/report.json" --open',
-            skill_text,
-        )
-        self.assertIn(
-            "- Your agent skill report: file://$REPORT_DIR/report.html",
-            skill_text,
-        )
-        self.assertNotIn("cta_url", skill_text)
-        self.assertNotIn("[View in browser]", skill_text)
-
-    def test_skill_edits_only_use_failed_conversations(self):
-        skill_path = Path(__file__).resolve().parent.parent / "SKILL.md"
-        skill_text = skill_path.read_text()
-
-        self.assertIn(
-            "`raw_efficiency` = mean of efficiency scores across all **verified** sessions",
-            skill_text,
-        )
-        self.assertIn(
-            "`curve(score) = 0.5 + 0.5 * score`",
-            skill_text,
-        )
-        self.assertIn(
-            "`overall = 0.5 * efficiency + 0.35 * code_quality + "
-            "0.15 * skill_coverage.`",
-            skill_text,
-        )
-        self.assertIn(
-            "from each conversation's raw, uncurved, **verified** scorer results",
-            skill_text,
-        )
-        self.assertIn(
-            "Use only `failed_conversations` as evidence for "
-            "skill-improvement suggestions and draft skill edits",
-            skill_text,
-        )
-        self.assertIn("Only `verified: true` results are aggregated", skill_text)
-
-    def test_report_renders_letter_grade(self):
-        page = render_page({
-            "scores": {
-                "efficiency": 0.7,
-                "code_quality": 0.7,
-                "skill_coverage": 0.8,
-                "overall": 0.7,
-            },
-        })
-
-        self.assertIn('<div class="grade">C-</div>', page)
-        self.assertIn('<div class="grade-label">overall 70</div>', page)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,196 +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_results(path, results):
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps({"results": results}), encoding="utf-8")
-
-
-def run_verify(results_path, out_dir, **kwargs):
-    argv = [str(results_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) / "results.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",
-            )
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "efficiency", "transcript_path": str(transcript), "label": "highly_efficient",
-                 "score": 1.0, "quote": "always use pnpm\n   for the   frontend build.",
-                 "reason": "the agent followed the stated convention directly", "session_id": "s1"},
-            ])
-            report = run_verify(results_path, tmp / "out")
-            self.assertTrue(report["results"][0]["verified"])
-            self.assertIsNone(report["results"][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")
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "code-quality", "transcript_path": str(transcript), "label": "block",
-                 "score": 0.2,
-                 "quote": "the agent should always prefer pnpm instead of npm here",
-                 "reason": "paraphrased, not quoted", "session_id": "s1"},
-            ])
-            report = run_verify(results_path, tmp / "out")
-            self.assertFalse(report["results"][0]["verified"])
-            self.assertEqual(report["results"][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")
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "efficiency", "transcript_path": str(transcript), "label": "mostly_inefficient",
-                 "score": 0.4, "quote": "ALWAYS USE PNPM HERE",
-                 "reason": "case differs from transcript", "session_id": "s1"},
-            ])
-            report = run_verify(results_path, tmp / "out")
-            result = report["results"][0]
-            self.assertFalse(result["verified"])
-            self.assertEqual(result["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")
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "efficiency", "transcript_path": str(transcript), "label": "highly_efficient",
-                 "score": 1.0, "quote": "pnpm", "reason": "too short to prove anything",
-                 "session_id": "s1"},
-            ])
-            report = run_verify(results_path, tmp / "out")
-            result = report["results"][0]
-            self.assertFalse(result["verified"])
-            self.assertEqual(result["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")
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "efficiency", "transcript_path": str(transcript), "label": "highly_efficient",
-                 "score": 1.0, "quote": "", "reason": "no citation given", "session_id": "s1"},
-            ])
-            report = run_verify(results_path, tmp / "out")
-            self.assertEqual(report["results"][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"
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "code-quality", "transcript_path": str(missing_transcript), "label": "block",
-                 "score": 0.2, "quote": "always use pnpm here for the build",
-                 "reason": "transcript file is gone", "session_id": "s1"},
-            ])
-            report = run_verify(results_path, tmp / "out")
-            result = report["results"][0]
-            self.assertFalse(result["verified"])
-            self.assertEqual(result["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")
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "efficiency", "transcript_path": str(transcript), "label": "highly_efficient",
-                 "score": 1.0, "quote": "Always use pnpm for the frontend build",
-                 "reason": "first citation", "session_id": "s1"},
-                {"scorer": "code-quality", "transcript_path": str(transcript), "label": "approve",
-                 "score": 1.0, "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(results_path, tmp / "out")
-            self.assertEqual(spy.call_count, 1)
-            self.assertTrue(all(r["verified"] for r in report["results"]))
-            self.assertEqual(report["stats"]["by_transcript"][str(transcript)]["total"], 2)
-
-
-class MalformedInputTests(unittest.TestCase):
-    def test_invalid_json_exits_non_zero(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            results_path = tmp / "results.json"
-            results_path.write_text("{not json", encoding="utf-8")
-            with self.assertRaises(SystemExit) as ctx:
-                vc.main([str(results_path), "--out", str(tmp / "out")])
-            self.assertNotEqual(ctx.exception.code, 0)
-
-    def test_missing_results_key_exits_non_zero(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            tmp = Path(tmp)
-            results_path = tmp / "results.json"
-            results_path.write_text(json.dumps({"nope": []}), encoding="utf-8")
-            with self.assertRaises(SystemExit) as ctx:
-                vc.main([str(results_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)
-            results_path = tmp / "results.json"
-            write_results(results_path, [
-                {"scorer": "code-quality", "transcript_path": str(tmp / "missing.md"), "label": "block",
-                 "score": 0.2, "quote": "this quote will not verify at all",
-                 "reason": "bad citation", "session_id": "s1"},
-            ])
-            try:
-                vc.main([str(results_path), "--out", str(tmp / "out")])
-            except SystemExit as exc:
-                self.fail(f"main() exited with {exc.code} on a merely-unverified result")
-
-
-if __name__ == "__main__":
-    unittest.main()