Skip to content

Hermes Agent context engine: the main model writes the compaction handoff on its cached prompt prefix

104 KB
Raw Blame
"""Check the issue policy with fake API replies. No network is used."""

from __future__ import annotations

import copy
import io
import json
import os
import re
import tempfile
import unittest
from contextlib import redirect_stdout
from pathlib import Path
from unittest.mock import patch
from urllib.error import HTTPError, URLError
from urllib.parse import parse_qs, urlsplit

from scripts import check_issue_policy as policy

REPOSITORY = "owner/repo"
ACTIVATED_AT = "2026-10-08T17:09:42Z"
PR_PATH = "/repos/owner/repo/pulls/23"
TEST_CONFIRMATION = "- [x] I ran all tests listed in CONTRIBUTING.md and all passed."
NO_AGENT = "## AI agent use\nNo AI agent used\n\n" + TEST_CONFIRMATION
AGENT_USE = "## AI agent use\nHarness: Codex\nModel: gpt-6.1-sol\nWork: Write policy tests.\n\n" + TEST_CONFIRMATION


def pull(**changes):
    data = {
        "number": 23,
        "body": "Closes #7\n\n" + NO_AGENT,
        "created_at": "2026-10-08T18:00:00Z",
        "updated_at": "2026-10-08T18:00:00Z",
        "state": "open",
        "merged": False,
        "user": {"login": "contributor"},
        "base": {"repo": {"full_name": REPOSITORY}, "ref": "main", "sha": "base-sha"},
        "head": {"repo": {"full_name": "contributor/fork"}, "ref": "change", "sha": "head-sha"},
    }
    data.update(changes)
    return data


def issue(number=7, **changes):
    data = {
        "number": number,
        "html_url": f"https://github.com/{REPOSITORY}/issues/{number}",
        "created_at": "2026-10-08T16:00:00Z",
        "state": "open",
        "user": {"login": "another-author"},
    }
    data.update(changes)
    return data


class FakeApi:
    def __init__(self, *responses, list_responses=None):
        self.responses = list(responses)
        self.paths = []
        self.list_responses = list(list_responses or [])
        self.explicit_list_responses = list_responses is not None
        self.list_paths = []
        self.default_open_pulls = [open_pull(author=responses[0]["user"]["login"])] if (
            responses and isinstance(responses[0], dict) and isinstance(responses[0].get("user", {}).get("login"), str)
        ) else []

    def get_list(self, path):
        self.list_paths.append(path)
        if not self.list_responses:
            if self.explicit_list_responses:
                raise AssertionError("An unexpected list API read was requested.")
            return copy.deepcopy(self.default_open_pulls)
        response = self.list_responses.pop(0)
        if isinstance(response, Exception):
            raise response
        return copy.deepcopy(response)

    def get(self, path):
        self.paths.append(path)
        if not self.responses:
            raise AssertionError("An unexpected API read was requested.")
        response = self.responses.pop(0)
        if isinstance(response, Exception):
            raise response
        return copy.deepcopy(response)


def open_pull(number=23, author="contributor", **changes):
    data = issue(number, user={"login": author}, html_url=f"https://github.com/{REPOSITORY}/pull/{number}")
    data["pull_request"] = {"url": f"https://api.github.com/repos/{REPOSITORY}/pulls/{number}", "merged_at": None}
    data.update(changes)
    return data


class OpenPullLimitTests(unittest.TestCase):
    def test_large_later_page_restarts_with_fresh_sets(self):
        first = [open_pull()] + [issue(number, user={"login": "contributor"}) for number in range(100, 199)]
        api = FakeApi(list_responses=[first, policy.ResponseTooLarge(), first[:50], first[50:], [open_pull(24)]])
        self.assertEqual(policy.author_open_pulls(api, REPOSITORY, "contributor", 23), frozenset({23, 24}))
        queries = [parse_qs(urlsplit(path).query) for path in api.list_paths]
        self.assertEqual([(int(q["per_page"][0]), int(q["page"][0])) for q in queries],
                         [(100, 1), (100, 2), (50, 1), (50, 2), (50, 3)])

    def test_five_pass_and_six_refuse_after_page_shrink(self):
        for count in (5, 6):
            with self.subTest(count=count):
                items = [open_pull(number) for number in range(23, 23 + count)]
                pages = [policy.ResponseTooLarge(), items]
                if count == 5:
                    pages += [policy.ResponseTooLarge(), items]
                api = FakeApi(pull(), issue(), pull(), list_responses=pages)
                self.assertEqual(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0], count == 5)
                self.assertFalse(api.list_responses)

    def test_page_shrink_is_bounded_and_single_item_overflow_refuses(self):
        api = FakeApi(list_responses=[policy.ResponseTooLarge() for _ in range(7)])
        with self.assertRaisesRegex(policy.PolicyError, "size limit.*unknown"):
            policy.author_open_pulls(api, REPOSITORY, "contributor", 23)
        queries = [parse_qs(urlsplit(path).query) for path in api.list_paths]
        self.assertEqual([int(q["per_page"][0]) for q in queries], [100, 50, 25, 12, 6, 3, 1])
        self.assertEqual([q["page"] for q in queries], [["1"]] * 7)

    def test_non_size_api_error_has_no_retry(self):
        api = FakeApi(list_responses=[policy.ApiError(500)])
        with self.assertRaises(policy.ApiError):
            policy.author_open_pulls(api, REPOSITORY, "contributor", 23)
        self.assertEqual(len(api.list_paths), 1)

    def test_small_page_keeps_duplicate_membership_and_size_checks(self):
        cases = [[open_pull(), open_pull()], [open_pull(24)], [open_pull()] * 51]
        for items in cases:
            with self.subTest(length=len(items)):
                api = FakeApi(list_responses=[policy.ResponseTooLarge(), items])
                with self.assertRaises(policy.PolicyError):
                    policy.author_open_pulls(api, REPOSITORY, "contributor", 23)

    def test_small_full_page_requires_next_page_and_keeps_page_bound(self):
        items = [open_pull()] + [issue(number, user={"login": "contributor"}) for number in range(100, 149)]
        api = FakeApi(list_responses=[policy.ResponseTooLarge(), items, []])
        self.assertEqual(policy.author_open_pulls(api, REPOSITORY, "contributor", 23), frozenset({23}))
        self.assertEqual(len(api.list_paths), 3)
        api = FakeApi(list_responses=[policy.ResponseTooLarge(), items])
        with patch.object(policy, "OPEN_PR_PAGE_LIMIT", 1):
            with self.assertRaisesRegex(policy.PolicyError, "page limit.*unknown"):
                policy.author_open_pulls(api, REPOSITORY, "contributor", 23)

    def test_small_page_set_change_still_aborts_pass(self):
        first = [open_pull(number) for number in range(23, 28)]
        api = FakeApi(pull(), issue(), pull(), list_responses=[
            policy.ResponseTooLarge(), first, policy.ResponseTooLarge(), first[:-1],
        ])
        with self.assertRaisesRegex(policy.PolicyError, "open PR list changed"):
            policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)

    def test_five_open_prs_pass_after_two_count_reads(self):
        items = [open_pull(number) for number in (23, 24, 25, 26, 27)]
        api = FakeApi(pull(), issue(), pull(), list_responses=[items, items])
        self.assertTrue(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])
        self.assertEqual(len(api.list_paths), 2)

    def test_six_open_prs_fail(self):
        items = [open_pull(number) for number in (23, 24, 25, 26, 27, 28)]
        api = FakeApi(pull(), issue(), pull(), list_responses=[items])
        passed, message = policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)
        self.assertFalse(passed)
        self.assertIn("5", message)

    def test_owner_has_no_open_pr_limit_exception(self):
        for author in ("Elevatormusic", "ELEVATORMUSIC"):
            with self.subTest(author=author):
                data = pull(user={"login": author}, body=NO_AGENT)
                items = [open_pull(number, author) for number in (23, 24, 25, 26, 27, 28)]
                api = FakeApi(data, data, list_responses=[items])
                passed, message = policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)
                self.assertFalse(passed)
                self.assertIn("6", message)
                self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_drafts_older_prs_and_all_base_branches_count(self):
        items = [open_pull(number) for number in (23, 24, 25, 26)]
        items += [
            open_pull(27, draft=True, created_at="2026-10-08T17:09:41Z"),
            open_pull(28, base={"ref": "another-branch"}),
        ]
        api = FakeApi(pull(), issue(), pull(), list_responses=[items])
        self.assertFalse(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])
        query = parse_qs(urlsplit(api.list_paths[0]).query)
        self.assertEqual(query, {
            "state": ["open"], "creator": ["contributor"], "sort": ["created"],
            "direction": ["asc"], "per_page": ["100"], "page": ["1"],
        })

    def test_closed_merged_prs_and_ordinary_issues_do_not_count(self):
        merged = open_pull(29)
        merged["pull_request"]["merged_at"] = "2026-10-08T18:01:00Z"
        items = [open_pull(number) for number in (23, 24, 25, 26, 27)] + [
            open_pull(28, state="closed"), merged, issue(30, user={"login": "contributor"}),
        ]
        api = FakeApi(pull(), issue(), pull(), list_responses=[items, items])
        self.assertTrue(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])

    def test_open_pr_without_optional_merged_timestamp_counts(self):
        items = [open_pull(number) for number in (23, 24, 25, 26, 27)]
        for item in items:
            del item["pull_request"]["merged_at"]
        api = FakeApi(pull(), issue(), pull(), list_responses=[items, items])
        self.assertTrue(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])
        items.append(open_pull(28))
        del items[-1]["pull_request"]["merged_at"]
        api = FakeApi(pull(), issue(), pull(), list_responses=[items])
        self.assertFalse(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])

    def test_case_insensitive_author(self):
        data = pull(user={"login": "ConTRibutor"})
        items = [open_pull(author="CONTRIBUTOR")]
        api = FakeApi(data, issue(), data, list_responses=[items, items])
        self.assertTrue(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])

    def test_query_values_are_encoded(self):
        author = "contributor&state=all#fragment"
        items = [open_pull(author=author)]
        api = FakeApi(list_responses=[items])
        self.assertEqual(policy.author_open_pulls(api, REPOSITORY, author, 23), frozenset({23}))
        parsed = urlsplit(api.list_paths[0])
        self.assertEqual(parsed.path, "/repos/owner/repo/issues")
        self.assertEqual(parsed.fragment, "")
        self.assertEqual(parse_qs(parsed.query)["creator"], [author])
        self.assertEqual(parse_qs(parsed.query)["state"], ["open"])

    def test_pagination_passes_only_after_all_issue_pages_are_read_twice(self):
        first = [issue(number, user={"login": "contributor"}) for number in range(100, 200)]
        second = [open_pull(number) for number in (23, 24, 25, 26, 27)]
        api = FakeApi(pull(), issue(), pull(), list_responses=[first, second, first, second])
        self.assertTrue(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])
        self.assertEqual([parse_qs(urlsplit(path).query)["page"] for path in api.list_paths],
                         [["1"], ["2"], ["1"], ["2"]])
        self.assertFalse(api.list_responses)

    def test_sixth_pr_on_a_later_page_refuses(self):
        first = [open_pull(number) for number in (23, 24, 25, 26, 27)]
        first += [issue(number, user={"login": "contributor"}) for number in range(100, 195)]
        api = FakeApi(pull(), issue(), pull(), list_responses=[first, [open_pull(28)]])
        self.assertFalse(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])
        self.assertEqual(len(api.list_paths), 2)

    def test_full_final_page_needs_an_empty_page(self):
        items = [open_pull()] + [issue(number, user={"login": "contributor"}) for number in range(100, 199)]
        api = FakeApi(list_responses=[items, []])
        self.assertEqual(policy.author_open_pulls(api, REPOSITORY, "contributor", 23), frozenset({23}))
        self.assertEqual(len(api.list_paths), 2)

    def test_page_limit_refuses_an_unknown_count(self):
        pages = [
            [open_pull()] + [issue(number, user={"login": "contributor"}) for number in range(100, 199)],
            [issue(number, user={"login": "contributor"}) for number in range(200, 300)],
        ]
        api = FakeApi(list_responses=pages)
        with patch.object(policy, "OPEN_PR_PAGE_LIMIT", 2):
            with self.assertRaisesRegex(policy.PolicyError, "page limit.*unknown"):
                policy.author_open_pulls(api, REPOSITORY, "contributor", 23)
        self.assertEqual(len(api.list_paths), 2)

    def test_current_pr_must_be_present_and_open(self):
        for items in ([], [open_pull(24)], [open_pull(state="closed")]):
            with self.subTest(items=items):
                api = FakeApi(pull(), issue(), pull(), list_responses=[items])
                with self.assertRaisesRegex(policy.PolicyError, "current pull request is missing"):
                    policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)

    def test_malformed_list_data_refuses(self):
        cases = [
            {}, None, [None], ["not-an-item"], [open_pull(number=True)], [open_pull(number=0)],
            [open_pull(state="unknown")], [open_pull(user={})], [open_pull(user={"login": "another-author"})],
            [open_pull(html_url="https://github.com/other/repo/pull/23")], [open_pull(html_url=None)],
            [open_pull(pull_request=None)], [open_pull(pull_request={})],
            [open_pull(pull_request={"url": "https://api.example.com/repos/owner/repo/pulls/23", "merged_at": None})],
            [open_pull(pull_request={"url": "https://api.github.com/repos/owner/repo/pulls/23", "merged_at": "bad"})],
            [open_pull(draft="true")], [open_pull()] * 101,
        ]
        for items in cases:
            with self.subTest(items=items):
                with self.assertRaises(policy.PolicyError):
                    policy.author_open_pulls(FakeApi(list_responses=[items]), REPOSITORY, "contributor", 23)

    def test_duplicate_items_on_same_or_later_pages_refuse(self):
        first = [open_pull()] + [issue(number, user={"login": "contributor"}) for number in range(100, 199)]
        for pages in ([[open_pull(), open_pull()]], [first, [issue(100, user={"login": "contributor"})]]):
            with self.subTest(pages=len(pages)):
                with self.assertRaisesRegex(policy.PolicyError, "incomplete or inconsistent"):
                    policy.author_open_pulls(FakeApi(list_responses=pages), REPOSITORY, "contributor", 23)

    def test_list_api_errors_refuse_on_both_reads_and_later_pages(self):
        first = [open_pull()] + [issue(number, user={"login": "contributor"}) for number in range(100, 199)]
        for status in (None, 403, 404, 429, 500):
            for pages in ([policy.ApiError(status)], [[open_pull()], policy.ApiError(status)],
                          [first, policy.ApiError(status)]):
                with self.subTest(status=status, pages=len(pages)):
                    api = FakeApi(pull(), issue(), pull(), list_responses=pages)
                    with self.assertRaises(policy.ApiError):
                        policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)

    def test_open_pr_set_changes_abort_a_pass(self):
        first = [open_pull(number) for number in (23, 24, 25, 26, 27)]
        for last in (first + [open_pull(28)], first[:-1], first[:-1] + [open_pull(28)]):
            with self.subTest(numbers=[item["number"] for item in last]):
                api = FakeApi(pull(), issue(), pull(), list_responses=[first, last])
                with self.assertRaisesRegex(policy.PolicyError, "open PR list changed"):
                    policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)

    def test_old_candidate_skips_count_even_above_limit(self):
        api = FakeApi(pull(created_at="2026-10-08T17:09:41Z"), list_responses=[
            [open_pull(number) for number in (23, 24, 25, 26, 27, 28)],
        ])
        self.assertTrue(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])
        self.assertEqual(api.list_paths, [])


class ReviewRegressionTests(unittest.TestCase):
    def test_link_destination_cannot_close_details(self):
        body = "<details><summary>Example</summary>\n\n[sample](</details>)\n\nCloses #7\n\n" + NO_AGENT
        body += "\n</details>"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_incomplete_link_cannot_mask_a_raw_html_block(self):
        body = "[sample](target\n<pre>\n)\n\nCloses #7\n\n" + NO_AGENT
        with self.assertRaises(policy.PolicyError):
            policy.body_requirement(body)

    def test_indented_html_cannot_continue_a_bare_link_destination(self):
        body = "[sample](target\n    <pre>\n)\n\nCloses #7\n\n" + NO_AGENT
        with self.assertRaises(policy.PolicyError):
            policy.body_requirement(body)

    def test_inline_html_cannot_continue_a_bare_link_destination(self):
        body = "[sample](target\ntext <pre>\n)\n\nCloses #7\n\n" + NO_AGENT
        with self.assertRaises(policy.PolicyError):
            policy.body_requirement(body)

    def test_unquoted_html_cannot_follow_a_link_destination(self):
        body = "[sample](target <pre>)\n\nCloses #7\n\n" + NO_AGENT
        with self.assertRaises(policy.PolicyError):
            policy.body_requirement(body)

    def test_extra_text_cannot_follow_a_completed_link_title(self):
        body = '[sample](target "title" <pre>)\n\nCloses #7\n\n' + NO_AGENT
        with self.assertRaises(policy.PolicyError):
            policy.body_requirement(body)

    def test_raw_html_heading_ends_the_ai_section(self):
        body = "## AI agent use\n\n<h2>Other section</h2>\n\nNo AI agent used\n\n" + TEST_CONFIRMATION
        self.assertIsNotNone(policy.body_requirement(body))

    def test_punctuated_placeholder_values_do_not_supply_disclosure(self):
        for value in ("TODO.", "unknown.", "not run."):
            with self.subTest(value=value):
                body = AGENT_USE.replace("Work: Write policy tests.", "Work: " + value)
                self.assertIsNotNone(policy.body_requirement(body))

    def test_link_destinations_and_titles_keep_details_hidden(self):
        samples = (
            "[sample](</details>)", '[sample](target "</details>")', "[sample](target '</details>')",
            r'[sample](target "escaped \" </details>")', "[id]: </details>", '[id]: target "</details>"',
        )
        for sample in samples:
            with self.subTest(sample=sample):
                body = "<details>\n\n" + sample + "\n\nCloses #7\n\n" + NO_AGENT + "\n</details>"
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
                public = body + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_incomplete_links_refuse_markdown_block_interruptions(self):
        blocks = (
            "<pre>", "<script>", "<style>", "<textarea>", "<!--", "<?pi", "<!DOCTYPE html>",
            "<![CDATA[", "<div>", "</details>", "```text", "~~~text", "## Other", "- item",
            "1. item", "> quote", "---", "===", "***",
        )
        for prefix in ('[sample](target\n', '[sample](target "first\n', '[id]:\n', '[id]: target "first\n'):
            for block in blocks:
                with self.subTest(prefix=prefix, block=block):
                    with self.assertRaises(policy.PolicyError):
                        policy.plain_lines(prefix + block + '\nlast")\n\n')

    def test_multiline_links_preserve_noninterrupting_text_and_type_seven_html(self):
        samples = (
            '[sample](target\n "two\nlines")', '[id]: target\n "two\nlines"',
            "[sample](target\n)", "[sample](\n<span>\n)", '[sample](target\n (title))',
        )
        for sample in samples:
            body = sample + "\n\nCloses #7\n\n" + NO_AGENT
            self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
            self.assertIsNone(policy.body_requirement(body))
        for sample in ('[sample](target "first\n<span>\nlast")', '[id]: target "first\n<span>\nlast"'):
            body = "<details>\n\n" + sample + "\n\nCloses #7\n\n" + NO_AGENT + "\n</details>"
            self.assertEqual(policy.issue_references(body, REPOSITORY), [])
            self.assertIsNotNone(policy.body_requirement(body))

    def test_started_link_destinations_cannot_cross_a_line_ending(self):
        for sample in ("[sample](target\nmore)", "[sample](<target\nmore>)", "[id]: <target\nmore>",
                       "[sample](target(\nmore))", "[id]: target(\nmore)"):
            with self.subTest(sample=sample):
                with self.assertRaises(policy.PolicyError):
                    policy.plain_lines(sample)

    def test_link_targets_refuse_extra_text_after_destination_or_title(self):
        samples = (
            '[sample](target extra)', '[sample](target "title" extra)', '[sample](<target>extra)',
            '[id]: target extra', '[id]: target "title" extra', '[sample](target "title"\n"extra")',
            "[sample](target(</details>))", r"[sample](target\(</details>\))",
        )
        for sample in samples:
            with self.subTest(sample=sample):
                with self.assertRaises(policy.PolicyError):
                    policy.plain_lines(sample)

    def test_link_target_guards_preserve_urls_angles_and_titles(self):
        samples = (
            '[sample](https://example.test/path?a=1&b=2)', '[sample](<https://example.test/a path>)',
            '[sample](target(nested))', r'[sample](target\(escaped\))',
            '[sample](target "title")', "[sample](target 'title')", '[id]: <target> "title"',
        )
        for sample in samples:
            with self.subTest(sample=sample):
                body = sample + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_link_suffix_markup_is_still_scanned_after_target_closes(self):
        body = '[sample](target "title")<!--\nCloses #7\n\n' + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))
        with self.assertRaises(policy.PolicyError):
            policy.plain_lines('[id]: target\n  "title"<!--\n\n')

    def test_incomplete_or_deep_link_targets_refuse_unknown_markup(self):
        samples = (
            "[sample](target", '[sample](target "title', "[id]:", "[sample](<target", "[sample](" + "(" * 33,
        )
        for sample in samples:
            with self.subTest(sample=sample):
                with self.assertRaises(policy.PolicyError):
                    policy.plain_lines(sample)

    def test_html_heading_levels_end_ai_without_accepting_html_ai_heading(self):
        for level in range(1, 7):
            for disclosure in ("No AI agent used", "Harness: Codex\nModel: test-model\nWork: Test"):
                body = f"## AI agent use\n\n<h{level} title='Other'>Other</h{level}>\n\n" + disclosure
                body += "\n\n" + TEST_CONFIRMATION
                self.assertIsNotNone(policy.body_requirement(body))
            body = f"<h{level}>AI agent use</h{level}>\n\nNo AI agent used\n\n" + TEST_CONFIRMATION
            self.assertIsNotNone(policy.body_requirement(body))

    def test_fake_html_headings_do_not_end_the_ai_section(self):
        for sample in ("`<h2>Other</h2>`", "```\n<h2>Other</h2>\n```", "    <h2>Other</h2>",
                       "<!-- <h2>Other</h2> -->", "<pre>\n<h2>Other</h2>\n</pre>",
                       '<span title="<h2>Other</h2>">text</span>', '[sample](target "<h2>Other</h2>")'):
            with self.subTest(sample=sample):
                body = "## AI agent use\n\n" + sample + "\n\nNo AI agent used\n\n" + TEST_CONFIRMATION
                self.assertIsNone(policy.body_requirement(body))

    def test_placeholder_punctuation_normalization_keeps_real_values(self):
        for field in ("Harness", "Model", "Work"):
            for value in ("(TODO.)", "unknown!", "not run…", "“TODO.”"):
                with self.subTest(field=field, value=value):
                    body = re.sub(rf"(?m)^{field}:.*$", f"{field}: {value}", AGENT_USE)
                    self.assertIsNotNone(policy.body_requirement(body))
            for value in ("Codex.", "gpt-6.1-sol", "C++", "Test: parser behavior."):
                body = re.sub(rf"(?m)^{field}:.*$", f"{field}: {value}", AGENT_USE)
                self.assertIsNone(policy.body_requirement(body))

    def test_list_fence_close_does_not_open_a_top_level_fence(self):
        body = "- ```text\n  example\n  ```\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_malformed_literal_closes_do_not_release_policy_lines(self):
        for tag, closing in (("script", "</script/>"), ("pre", "</pre bogus>")):
            with self.subTest(tag=tag):
                body = f"<{tag}>\n{closing}\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))

    def test_setext_other_section_cannot_supply_missing_ai_disclosure(self):
        for disclosure in ("No AI agent used", "Harness: Codex\nModel: test-model\nWork: Test"):
            with self.subTest(disclosure=disclosure):
                body = "## AI agent use\n\nOther section\n-------------\n" + disclosure + "\n\n" + TEST_CONFIRMATION
                self.assertIsNotNone(policy.body_requirement(body))

    def test_top_level_indented_code_cannot_open_markup_state(self):
        for sample in ("    <!--", "    <pre>"):
            with self.subTest(sample=sample):
                body = sample + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_list_fences_keep_nested_fields_hidden_and_restore_public_lines(self):
        for prefix in ("- ", "+ ", "* ", "1. ", "123) ", "  - "):
            for marker in ("```", "~~~"):
                with self.subTest(prefix=prefix, marker=marker):
                    indent = " " * len(prefix)
                    nested_body = "Closes #7\n" + NO_AGENT
                    sample = prefix + marker + "text\n" + "\n".join(indent + line for line in nested_body.split("\n"))
                    sample += "\n" + indent + marker
                    self.assertEqual(policy.issue_references(sample, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(sample))
                    public = sample + "\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(public))
        body = "- ```text\n  <!--\n  </details>\n  <pre>\n  ```\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_unclosed_list_fence_ends_when_the_list_container_ends(self):
        body = "- ```text\n  example\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))
        hidden = "- ```text\n  Closes #7\n  " + NO_AGENT.replace("\n", "\n  ")
        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(hidden))

    def test_literal_raw_ends_need_exact_tag_and_recover_after_real_end(self):
        for tag in ("pre", "script", "style", "textarea"):
            for ending in (f"</{tag}/>", f"</{tag} bogus>", f"</{tag} >", f"</{tag}\n>"):
                with self.subTest(tag=tag, ending=ending):
                    body = f"<{tag}>\n{ending}\n\nCloses #7\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(body))
                    public = body + f"\n</{tag.upper()}>\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(public))
        body = "<code>\n</code >\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_setext_heading_paragraph_cannot_supply_plain_policy_fields(self):
        for underline in ("===", "---"):
            for text in ("No AI agent used", "Harness: Codex\nModel: test-model\nWork: Test"):
                with self.subTest(underline=underline, text=text):
                    body = "## AI agent use\n\n" + text + "\n" + underline + "\n\n" + TEST_CONFIRMATION
                    self.assertIsNotNone(policy.body_requirement(body))
            body = "Closes #7\n" + underline + "\n\n" + NO_AGENT
            self.assertEqual(policy.issue_references(body, REPOSITORY), [])
            body = "AI agent use\n" + underline + "\nNo AI agent used\n\n" + TEST_CONFIRMATION
            self.assertIsNotNone(policy.body_requirement(body))

    def test_setext_boundaries_preserve_disclosure_in_the_correct_section(self):
        for underline in ("===", "---"):
            body = NO_AGENT.replace(TEST_CONFIRMATION, "Other section\n" + underline + "\n\n" + TEST_CONFIRMATION)
            self.assertIsNone(policy.body_requirement(body))
        for sample in ("```text\nOther section\n---\n```", "    Other section\n    ---", "<pre>\nOther\n---\n</pre>"):
            body = "## AI agent use\n\n" + sample + "\n\nNo AI agent used\n\n" + TEST_CONFIRMATION
            self.assertIsNone(policy.body_requirement(body))

    def test_indented_code_markup_variants_restore_public_lines(self):
        for indent in ("    ", "\t", " \t", "   \t"):
            for sample in ("<!--", "<pre>", "<?example", "<![CDATA[", "</details>", "$$"):
                with self.subTest(indent=repr(indent), sample=sample):
                    body = indent + sample + "\n" + indent + "Closes #7\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(body, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(body))

    def test_indentation_does_not_override_raw_html_or_paragraph_continuations(self):
        for prefix in ("<div>\n", "Prose\n"):
            with self.subTest(prefix=prefix):
                body = prefix + "    <!--\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
        body = "<pre>\n    </pre>\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))


    def test_disclosure_values_need_a_letter_or_number(self):
        for field in ("Harness", "Model", "Work"):
            for value in ("-", "?", "!", "@#$", "☀", "&amp;"):
                with self.subTest(field=field, value=value):
                    body = re.sub(rf"(?m)^{field}:.*$", f"{field}: {value}", AGENT_USE)
                    self.assertIsNotNone(policy.body_requirement(body))

    def test_disclosure_values_allow_unicode_letters_digits_and_model_punctuation(self):
        for field in ("Harness", "Model", "Work"):
            for value in ("模型", "Codex", "123", "١٢٣", "gpt-6.1-sol", "Model (v2): test!"):
                with self.subTest(field=field, value=value):
                    body = re.sub(rf"(?m)^{field}:.*$", f"{field}: {value}", AGENT_USE)
                    self.assertIsNone(policy.body_requirement(body))

    def test_entity_only_disclosure_values_do_not_supply_visible_content(self):
        body = "## AI agent use\nHarness: &nbsp;\nModel: &#x20;\nWork: &ZeroWidthSpace;\n\n" + TEST_CONFIRMATION
        self.assertIsNotNone(policy.body_requirement(body))

    def test_math_tags_cannot_close_markdown_details(self):
        body = "<details><summary>Example</summary>\n\n" + r"$$\text{</details>}$$"
        body += "\n\nCloses #7\n\n" + NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_non_gfm_line_separators_do_not_create_policy_lines(self):
        for separator in ("\u2028", "\u0085"):
            with self.subTest(separator=repr(separator)):
                body = ("Closes #7\n\n" + NO_AGENT).replace("\n", separator)
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))

    def test_source_interrupts_prose_as_type_six_raw_html(self):
        body = "Prose\n<source>\nCloses #7\n## AI agent use\nNo AI agent used\n\n" + TEST_CONFIRMATION
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_each_disclosure_field_rejects_entity_and_unicode_only_invisible_values(self):
        values = ("&nbsp;", "&#32;", "&#x20;", "&ZeroWidthSpace;", "&#x2060;", "\u200b", "\u2060",
                  "\ufeff", "\u00ad", "\u0301", "\ufe0f", "\u115f", "\u3164", "\u2800")
        for field in ("Harness", "Model", "Work"):
            for value in values:
                with self.subTest(field=field, value=repr(value)):
                    body = re.sub(rf"(?m)^{field}:.*$", f"{field}: {value}", AGENT_USE)
                    self.assertIsNotNone(policy.body_requirement(body))

    def test_visible_decoded_and_unicode_disclosure_values_still_pass(self):
        for value in ("C&#111;dex", "Codex&nbsp;Desktop", "模型", "e\u0301 test", "\u200bCodex", "&amp;nbsp;"):
            with self.subTest(value=value):
                body = AGENT_USE.replace("Harness: Codex", "Harness: " + value)
                self.assertIsNone(policy.body_requirement(body))
        for value in ("&#84;ODO", "&lt;harness&gt;", "\u200bTODO\u200b"):
            with self.subTest(value=value):
                body = AGENT_USE.replace("Harness: Codex", "Harness: " + value)
                self.assertIsNotNone(policy.body_requirement(body))

    def test_same_line_and_multiline_math_leave_markdown_containers_hidden(self):
        for tag in ("details", "blockquote", "ul"):
            for expression in (rf"$$\text{{</{tag}>}}$$", "$$\n" + rf"\text{{</{tag}>}}" + "\n$$"):
                with self.subTest(tag=tag, expression=expression):
                    body = f"<{tag}>\n\n" + expression + "\n\nCloses #7\n\n" + NO_AGENT + f"\n</{tag}>"
                    self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(body))
                    public = body + "\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(public))

    def test_math_delimiters_do_not_override_literal_html_tags_or_attributes(self):
        for tag in ("pre", "code", "script", "style", "textarea"):
            with self.subTest(tag=tag):
                body = f"<{tag}>\n$$</{tag}>\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))
        body = "<details title='\n$$</details>\n'>\n\nCloses #7\n\n" + NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_gfm_cr_lf_and_crlf_line_endings_still_pass(self):
        for separator in ("\r", "\n", "\r\n"):
            with self.subTest(separator=repr(separator)):
                body = ("Closes #7\n\n" + NO_AGENT).replace("\n", separator)
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_unicode_separators_cannot_end_raw_html_blocks_as_blank_lines(self):
        for separator in ("\v", "\f", "\x1c", "\x1d", "\x1e", "\u0085", "\u2028", "\u2029", "\u00a0"):
            with self.subTest(separator=repr(separator)):
                body = "<div>\n" + separator + "\nCloses #7\n## AI agent use\nNo AI agent used\n" + TEST_CONFIRMATION
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
        for blank in ("", " ", "\t", " \t "):
            body = "<div>\n" + blank + "\nCloses #7\n\n" + NO_AGENT
            self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
            self.assertIsNone(policy.body_requirement(body))

    def test_source_raw_blocks_keep_boundaries_and_recover_after_blank(self):
        for source in ("<source>", "<SOURCE src='example'>", "   <source/>", "</source>"):
            with self.subTest(source=source):
                body = "Prose\n" + source + "\nCloses #7\n## AI agent use\nNo AI agent used\n" + TEST_CONFIRMATION
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
                public = body + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))
        body = "Prose\n<sources>\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_inline_tick_match_stops_at_setext_and_thematic_boundaries(self):
        for marker in ("---", "===", "***", "=", "--", "_ _ _", "- - -", "   *\t* * "):
            with self.subTest(marker=marker):
                body = "Prose `\n" + marker + "\nCloses #7\nanother `\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_setext_and_thematic_end_the_prose_paragraph_before_type_seven_html(self):
        for marker in ("---", "===", "***", "_ _ _"):
            with self.subTest(marker=marker):
                body = "Prose\n" + marker + "\n<span>\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNone(policy.body_requirement(body))

    def test_non_boundaries_keep_matched_inline_spans_and_fences(self):
        for marker in ("    ---", "a ===", "* - *", "== text", "\\---"):
            with self.subTest(marker=marker):
                body = "Prose `\n" + marker + "\nCloses #7\nanother `\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNone(policy.body_requirement(body))
        body = "```text\n---\n===\n***\nCloses #7\n```\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNone(policy.body_requirement(body))

    def test_unmatched_inline_ticks_do_not_hide_public_policy_fields(self):
        body = "An unmatched ` example.\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_inline_tick_match_stops_at_heading_boundary(self):
        body = "Prose `\n## AI agent use\nNo AI agent used\nAnother marker `\n\n" + TEST_CONFIRMATION
        self.assertIsNone(policy.body_requirement(body))
        body = "Closes #7\n\n" + AGENT_USE.replace("Work: Write policy tests.", "Work: Check the ` option.")
        self.assertIsNone(policy.body_requirement(body))

    def test_invalid_backtick_fence_info_does_not_hide_public_policy_fields(self):
        body = "```language`\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_escaped_details_close_cannot_release_hidden_policy_fields(self):
        body = "<details><summary>Example</summary>\n\n\\</details>\n\nCloses #7\n\n" + NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_unmatched_tick_lengths_are_literal_on_agent_work_line(self):
        for text in ("Use the ` option.", "Use ` and `` markers.", "Use `` and ``` markers."):
            with self.subTest(text=text):
                body = "Closes #7\n\n" + AGENT_USE.replace("Write policy tests.", text)
                self.assertIsNone(policy.body_requirement(body))

    def test_unmatched_ticks_do_not_disable_comments_or_literal_html(self):
        for opening, closing in (("<!--", "-->"), ("<pre>", "</pre>")):
            with self.subTest(opening=opening):
                body = "Example `" + opening + "\nCloses #7\n" + NO_AGENT + "\n" + closing
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
                public = body + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_tick_match_stops_at_fence_html_quote_and_list_boundaries(self):
        samples = [
            "```text\n`\n```", "~~~text\n`\n~~~", "<pre>`\n</pre>", "<div>`\n</div>",
            "<!-- ` -->", "<?example `?>", "<![CDATA[`]]>", "<!DOCTYPE example `>",
            "> Another ` marker", "- Another ` marker", "1. Another ` marker",
        ]
        for sample in samples:
            with self.subTest(sample=sample):
                body = "Prose `\n" + sample + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_type_seven_html_does_not_interrupt_matched_inline_span(self):
        body = "`\n<span>\nexample`\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_type_seven_html_does_not_interrupt_prose_paragraph(self):
        body = "Prose\n<span>\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_fence_info_rules_keep_valid_fences_and_literal_invalid_lines(self):
        for indent in ("", "   "):
            for opening in ("```text`", "````text`", r"```text\`", "```text```"):
                with self.subTest(indent=indent, opening=opening):
                    body = indent + opening + "\n\nCloses #7\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                    self.assertIsNone(policy.body_requirement(body))
            for opening, close in (("```text", "```"), ("````text", "````"), ("~~~text`", "~~~")):
                with self.subTest(indent=indent, opening=opening):
                    hidden = indent + opening + "\nCloses #7\n" + NO_AGENT + "\n" + close
                    self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(hidden))
                    self.assertIsNone(policy.body_requirement(hidden + "\n\n" + NO_AGENT))

    def test_markdown_html_escape_parity_preserves_real_container_close(self):
        for tag in ("details", "blockquote", "ul"):
            for count in (1, 2, 3, 4):
                with self.subTest(tag=tag, count=count):
                    body = f"<{tag}>\n\n" + "\\" * count + f"</{tag}>\n\nCloses #7\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(body, REPOSITORY), [] if count % 2 else [7])
                    self.assertEqual(policy.body_requirement(body) is None, count % 2 == 0)
                    body += f"\n</{tag}>\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(body, REPOSITORY), [8] if count % 2 else [7, 8])

    def test_html_escape_rules_stay_literal_in_raw_blocks_and_attributes(self):
        for tag in ("details", "pre", "code", "script", "style", "textarea"):
            with self.subTest(tag=tag):
                body = f"<{tag}>\n\\</{tag}>\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))
        body = "<details><summary title='\\</details>'>Example</summary>\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_escaped_html_starts_in_markdown_do_not_open_hidden_contexts(self):
        for opening in ("<details>", "<pre>", "<!--", "<?example", "<![CDATA[", "<!DOCTYPE example"):
            with self.subTest(opening=opening):
                body = "\\" + opening + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_optional_description_item_ends_recover_public_policy_lines(self):
        sample = "<dl>\n<dt>Term\n<dd>Definition\n</dl>"
        body = sample + "\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_optional_description_siblings_and_nested_lists(self):
        for sample in (
            "<dl><dt>First<dt>Second<dd>One<dd>Two<dt>Last</dt></dl>",
            "<dl><dt>Term<dd><dl><dt>Nested<dd>Definition</dl></dl>",
            "<dl><dt>Term<dd><ul><li>One<li>Two</ul></dl>",
        ):
            with self.subTest(sample=sample):
                body = sample + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_description_list_keeps_hidden_context_and_defined_end_rules(self):
        samples = [
            "`</dl>`", "```\n</dl>\n```", "    </dl>", "\t</dl>",
            '<span title="</dl><dt><dd>">text</span>', "<!-- </dl><dt><dd> -->", "<![CDATA[</dl><dt><dd>]]>",
            "</ul>",
        ]
        samples += [f"<{tag}></dl><dt><dd></{tag}>" for tag in ("pre", "code", "script", "style", "textarea")]
        for sample in samples:
            with self.subTest(sample=sample):
                body = "<dl><dt>Term<dd>Definition\n\n" + sample + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
        body = "<dl><dt>Term</dl>\n\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        for outer in ("details", "blockquote"):
            body = f"<{outer}>\n\n<dl><dt>Term<dd>Definition</dl>\n\nCloses #7\n\n{NO_AGENT}"
            self.assertEqual(policy.issue_references(body, REPOSITORY), [])
            self.assertIsNotNone(policy.body_requirement(body))
            body += f"\n</{outer}>\n\nCloses #7\n\n" + NO_AGENT
            self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
            self.assertIsNone(policy.body_requirement(body))

    def test_description_list_close_keeps_raw_block_until_blank(self):
        body = "Closes #7\n\n<dl><dt>Term<dd>Definition\n\n</dl>\n" + NO_AGENT
        self.assertIsNotNone(policy.body_requirement(body))

    def test_optional_list_item_end_recovers_public_policy_lines(self):
        for sample in ("<ul><li>First<li>Second</ul>", "<ol><li>First<li>Second</li></ol>"):
            with self.subTest(sample=sample):
                body = sample + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_optional_list_ends_keep_nested_lists_and_outer_containers(self):
        for tag in ("ul", "ol", "menu"):
            sample = f"<{tag}><li>First<ol><li>Nested<li>More</ol><li>Last</{tag}>"
            body = sample + "\n\nCloses #7\n\n" + NO_AGENT
            self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
            self.assertIsNone(policy.body_requirement(body))
            for outer in ("details", "blockquote"):
                body = f"<{outer}>\n\n{sample}\n\nCloses #7\n\n{NO_AGENT}\n</{outer}>"
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
                body += "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_optional_list_end_keeps_raw_close_boundary(self):
        body = "Closes #7\n\n<ul><li>Example</ul>\n" + NO_AGENT
        self.assertIsNotNone(policy.body_requirement(body))
        body = "Closes #7\n\n<ul><li>Example\n\n</ul>\n" + NO_AGENT
        self.assertIsNotNone(policy.body_requirement(body))

    def test_fake_optional_list_ends_cannot_release_hidden_fields(self):
        samples = [
            "`</ul>`", "```\n</ul>\n```", "    </ul>", "\t</ul>",
            '<span title="</ul><li>">text</span>', "<!-- </ul><li> -->", "<![CDATA[</ul><li>]]>",
            "</ol>",
        ]
        samples += [f"<{tag}></ul><li></{tag}>" for tag in ("pre", "code", "script", "style", "textarea")]
        for sample in samples:
            with self.subTest(sample=sample):
                body = "<ul><li>Example\n\n" + sample + "\n\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))

    def test_container_close_requires_blank_before_ai_heading(self):
        for tag in ("details", "blockquote"):
            for indent in ("", "   "):
                with self.subTest(tag=tag, indent=indent):
                    body = f"Closes #7\n\n<{tag}>\nExample\n\nSample\n{indent}</{tag}>\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                    self.assertIsNotNone(policy.body_requirement(body))

    def test_container_close_requires_blank_before_test_checkbox(self):
        for tag in ("details", "blockquote"):
            with self.subTest(tag=tag):
                body = "Closes #7\n\n## AI agent use\nNo AI agent used\n\n"
                body += f"<{tag}>\nExample\n\nSample\n</{tag}>\n" + TEST_CONFIRMATION
                self.assertIsNotNone(policy.body_requirement(body))

    def test_container_close_recovers_ai_heading_after_a_blank_line(self):
        for tag in ("details", "blockquote", "ul", "ol", "li", "dl", "dt", "dd"):
            for indent in ("", " ", "  ", "   "):
                for blank in ("", "   "):
                    with self.subTest(tag=tag, indent=indent, blank=blank):
                        body = f"Closes #7\n\n<{tag}>\nExample\n\nSample\n{indent}</{tag}>\n{blank}\n" + NO_AGENT
                        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                        self.assertIsNone(policy.body_requirement(body))

    def test_container_close_recovers_test_checkbox_after_a_blank_line(self):
        for tag in ("details", "blockquote"):
            with self.subTest(tag=tag):
                body = "Closes #7\n\n## AI agent use\nNo AI agent used\n\n"
                body += f"<{tag}>\nExample\n\nSample\n</{tag}>\n\n" + TEST_CONFIRMATION
                self.assertIsNone(policy.body_requirement(body))

    def test_literal_close_keeps_the_confirmed_heading_control(self):
        for tag in ("code", "pre", "script", "style", "textarea"):
            with self.subTest(tag=tag):
                body = f"Closes #7\n\n<{tag}>\nExample\n\nSample\n</{tag}>\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_container_close_suffix_is_raw_and_does_not_open_code(self):
        for suffix in ("`", "```", "~~~"):
            with self.subTest(suffix=suffix):
                hidden = "<details>\nExample\n\nSample\n</details>" + suffix + "\nCloses #7"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_details_inline_code_cannot_close_the_container(self):
        hidden = "<details>\n<summary>Example</summary>\n\n`</details>`\n`\nCloses #7\n" + NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(hidden))

    def test_details_fenced_code_cannot_close_the_container(self):
        hidden = "<details>\n<summary>Example</summary>\n\n```text\n</details>\n```\n\n```\nCloses #7\n"
        hidden += NO_AGENT + "\n```\n\n</details>"
        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(hidden))

    def test_details_indented_code_cannot_close_the_container(self):
        hidden = "<details>\n<summary>Example</summary>\n\n    </details>\n\nCloses #7\n"
        hidden += NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(hidden))

    def test_markdown_container_inline_code_preserves_the_real_close(self):
        for tag in ("details", "blockquote", "ul", "ol", "li", "dl", "dt", "dd"):
            for marker in ("`", "``"):
                with self.subTest(tag=tag, marker=marker):
                    hidden = f"<{tag}>\n\n{marker}</{tag}>{marker}\nCloses #7\n{NO_AGENT}\n</{tag}>"
                    self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(hidden))
                    public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(public))

    def test_multiline_container_code_span_ignores_fake_tags_and_comments(self):
        hidden = "<details>\n<summary>Example</summary>\n\n``\nexample </details>\nexample <!--\nexample <pre>\n``\n\n"
        hidden += "Closes #7\n"
        hidden += NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(hidden))
        public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
        self.assertIsNone(policy.body_requirement(public))

    def test_container_fences_ignore_fake_tags_and_restore_public_lines(self):
        for tag in ("details", "blockquote", "ul"):
            for marker in ("```", "~~~"):
                for indent in ("", "   "):
                    with self.subTest(tag=tag, marker=marker, indent=indent):
                        hidden = f"<{tag}>\n\n{indent}{marker}text\n</{tag}>\n<!--\n<pre>\n{indent}{marker}\n\n"
                        hidden += f"Closes #7\n{NO_AGENT}\n</{tag}>"
                        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                        self.assertIsNotNone(policy.body_requirement(hidden))
                        public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                        self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                        self.assertIsNone(policy.body_requirement(public))

    def test_container_indented_code_ignores_fake_tags_and_comments(self):
        for tag in ("details", "blockquote", "ul"):
            for indent in ("    ", "\t", " \t", "   \t"):
                with self.subTest(tag=tag, indent=indent):
                    hidden = f"<{tag}>\n\n{indent}</{tag}>\n{indent}<!--\n{indent}<pre>\n\nCloses #7\n"
                    hidden += NO_AGENT + f"\n</{tag}>"
                    self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(hidden))
                    public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(public))

    def test_literal_tags_keep_tag_behavior_inside_a_markdown_container(self):
        for tag in ("pre", "code", "script", "style", "textarea"):
            with self.subTest(tag=tag):
                hidden = f"<details>\n<summary>Example</summary>\n\n<{tag}>\n```\n</details>\n`</{tag}>`\n\n"
                hidden += "Closes #7\n" + NO_AGENT + "\n</details>"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_processing_instruction_suffix_comment_hides_declarations(self):
        body = "<?example\n?> <!--\nCloses #7\n" + NO_AGENT + "\n-->"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_cdata_suffix_comment_hides_declarations(self):
        body = "<![CDATA[\n]]><!--\nCloses #7\n" + NO_AGENT + "\n-->"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_details_with_blank_lines_hide_declarations(self):
        body = "<details>\n<summary>Example</summary>\n\nCloses #7\n" + NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_special_markup_ends_scan_comment_and_pre_suffixes(self):
        for opening, ending in (("<?example", "?>"), ("<![CDATA[", "]]>"), ("<!DOCTYPE example", ">")):
            for separator in ("", "\n"):
                for suffix, closing in (("<!--", "-->"), ("<!--", "--!>"), ("<pre>", "</pre>")):
                    with self.subTest(opening=opening, separator=separator, suffix=suffix, closing=closing):
                        hidden = opening + separator + ending + suffix + "\nCloses #7\n" + NO_AGENT + "\n" + closing
                        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                        self.assertIsNotNone(policy.body_requirement(hidden))
                        public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                        self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                        self.assertIsNone(policy.body_requirement(public))

    def test_special_markup_after_code_and_tag_suffixes_stays_hidden(self):
        for prefix in ("`\nexample`", "<span>example</span>"):
            for opening, ending in (("<?example", "?>"), ("<![CDATA[", "]]>"), ("<!DOCTYPE example", ">")):
                with self.subTest(prefix=prefix, opening=opening):
                    hidden = prefix + opening + "\nCloses #7\n" + NO_AGENT + "\n" + ending + "<!--"
                    hidden += "\nCloses #8\n" + NO_AGENT + "\n-->"
                    self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(hidden))
                    public = hidden + "\n\nCloses #9\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [9])
                    self.assertIsNone(policy.body_requirement(public))

    def test_special_markup_contents_do_not_interpret_tags_or_code(self):
        for opening, ending in (("<?example", "?>"), ("<![CDATA[", "]]>"), ("<!DOCTYPE example", ">")):
            with self.subTest(opening=opening):
                content = "<!-- <pre `" if ending == ">" else "<!-- <pre> `"
                hidden = opening + "\n" + content + "\nCloses #7\n" + NO_AGENT + "\n" + ending + "`"
                public = hidden + "\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_special_markup_inside_code_or_quoted_attributes_has_no_effect(self):
        for text in ("<?example", "<![CDATA[", "<!DOCTYPE example"):
            with self.subTest(text=text):
                body = "``\nexample " + text + "``\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))
                body = "`\nexample`<span title='" + text + "'>\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_unclosed_special_markup_and_details_keep_declarations_hidden(self):
        for opening in ("<?example", "<![CDATA[", "<!DOCTYPE example", "<details>\n<summary>Example</summary>"):
            with self.subTest(opening=opening):
                hidden = opening + "\n\nCloses #7\n" + NO_AGENT
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))

    def test_nested_details_keep_outer_contents_hidden_until_its_close(self):
        hidden = "<details>\n<summary>Outer</summary>\n\n<details>\n<summary>Inner</summary>\n\n</details>"
        hidden += "\n\nCloses #7\n" + NO_AGENT + "\n</details>"
        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(hidden))
        public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
        self.assertIsNone(policy.body_requirement(public))

    def test_details_attributes_and_comments_cannot_close_the_container(self):
        for opening in (
            '<details><span title="</details>">', "<details><span title='</details><!--'>",
            '<details><span\ntitle="\n</details>\n">',
            "<details>\n<!--\n</details>\n-->", "<details>\n<!-- </details> --!>",
            "<details>\n<![CDATA[\n</details>\n]]>",
        ):
            with self.subTest(opening=opening):
                hidden = opening + "\n\nCloses #7\n" + NO_AGENT + "\n</span></details>"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_details_open_flag_keeps_the_strict_plain_line_rule(self):
        for opening in ("<details open>", "<DETAILS open='open'>"):
            with self.subTest(opening=opening):
                hidden = opening + "\n<summary>Example</summary>\n\nCloses #7\n" + NO_AGENT + "\n</details>"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_raw_html_block_cannot_supply_declarations(self):
        body = "<div>\nCloses #7\n" + NO_AGENT + "\n</div>"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_markup_after_multiline_inline_code_is_still_scanned(self):
        body = "`\nexample`<!--\nCloses #7\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_block_math_cannot_supply_declarations(self):
        body = "$$\nCloses #7\n" + NO_AGENT + "\n$$"
        self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertIsNotNone(policy.body_requirement(body))

    def test_unrelated_repository_metadata_does_not_abort_a_pass(self):
        first = pull()
        last = copy.deepcopy(first)
        last["head"]["repo"]["stargazers_count"] = 1
        last["base"]["repo"]["updated_at"] = "2026-10-08T18:01:00Z"
        last["user"]["avatar_url"] = "https://example.com/avatar.png"
        self.assertTrue(policy.check_policy(FakeApi(first, issue(), last), REPOSITORY, 23, ACTIVATED_AT)[0])

    def test_checkbox_after_an_example_needs_a_blank_line(self):
        body = NO_AGENT.replace(TEST_CONFIRMATION, "- Example:\n" + TEST_CONFIRMATION)
        self.assertIsNotNone(policy.body_requirement(body))

    def test_raw_html_tag_blocks_need_a_blank_line_after_their_close(self):
        for opening, closing in (
            ("<div>", "</div>"), ("<TABLE>", "</TABLE>"), ("<details>", "</details>"),
            ("<section class='example'>", "</section>"), ("<div\nclass='example'>", "</div>"),
            ("<span>", "</span>"), ("<custom data-value=example>", "</custom>"),
            ("<img src=example.png />", ""), ("</custom>", ""), ("</div>", ""),
        ):
            with self.subTest(opening=opening):
                body = opening + "\nCloses #7\n## AI agent use\nNo AI agent used\n" + TEST_CONFIRMATION
                body += ("\n" + closing if closing else "") + "\nCloses #8"
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
                public = body + "\n\nCloses #9\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [9])
                self.assertIsNone(policy.body_requirement(public))

    def test_raw_html_special_blocks_keep_their_own_end_rule(self):
        for opening, closing in (("<?example", "?>"), ("<!DOCTYPE example", ">"), ("<![CDATA[", "]]>")):
            with self.subTest(opening=opening):
                body = opening + "\n\nCloses #7\n" + NO_AGENT + "\n" + closing
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
                public = body + "\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))
                one_line = opening + closing + "\n" + NO_AGENT
                self.assertIsNone(policy.body_requirement(one_line))

    def test_script_pre_style_and_textarea_end_at_the_matching_close(self):
        for tag in ("script", "pre", "style", "textarea"):
            with self.subTest(tag=tag):
                hidden = f"<{tag}>\n`\n\nCloses #7\n{NO_AGENT}\n</{tag}>"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_raw_html_does_not_interpret_code_or_math_markers(self):
        for marker in ("```", "`", "$$"):
            with self.subTest(marker=marker):
                body = "<div>\n" + marker + "\nCloses #7\n</div>\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(body))

    def test_text_and_autolinks_do_not_start_a_raw_html_block(self):
        for line in ("<https://example.com>", "<[email protected]>", "2 < 3", "Example: <span>word</span>"):
            with self.subTest(line=line):
                body = line + "\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))

    def test_inline_code_suffix_comments_and_pre_blocks_hide_declarations(self):
        for marker in ("`", "``"):
            for opening, closing in (("<!--", "-->"), ("<!--", "--!>"), ("<pre>", "</pre>")):
                with self.subTest(marker=marker, opening=opening, closing=closing):
                    hidden = marker + "\nexample" + marker + opening + "\nCloses #7\n" + NO_AGENT + "\n" + closing
                    self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(hidden))
                    public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(public))
        hidden = "``\nexample`different``<!--\nCloses #7\n" + NO_AGENT
        self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])

    def test_inline_code_does_not_interpret_markup_until_it_closes(self):
        for text in ("<!--", "<pre>", "<div>"):
            with self.subTest(text=text):
                body = "``\nexample " + text + "``\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))
        body = "`\nexample`<span title='<!--'>\nCloses #7\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
        self.assertIsNone(policy.body_requirement(body))

    def test_math_opening_content_and_blank_lines_stay_hidden(self):
        for opening in ("$$", "$$x + y", "   $$x + y"):
            with self.subTest(opening=opening):
                hidden = opening + "\n\nCloses #7\n" + NO_AGENT + "\n$$"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))
        self.assertIsNotNone(policy.body_requirement("$$\n" + NO_AGENT))

    def test_same_line_and_escaped_math_delimiters_do_not_hide_public_lines(self):
        for line in ("$$x + y$$", r"\$$", "Price: $$", r"$$x + y\\$$"):
            with self.subTest(line=line):
                body = line + "\nCloses #7\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(body, REPOSITORY), [7])
                self.assertIsNone(policy.body_requirement(body))
        body = "$$\n" + r"\$$" + "\nCloses #7\n" + NO_AGENT + "\n$$\n\nCloses #8\n\n" + NO_AGENT
        self.assertEqual(policy.issue_references(body, REPOSITORY), [8])
        self.assertIsNone(policy.body_requirement(body))

    def test_metadata_and_base_commit_changes_do_not_change_the_decision(self):
        for valid in (False, True):
            first = pull() if valid else pull(body="")
            last = copy.deepcopy(first)
            last.update(title="New title", labels=[{"name": "policy"}], draft=True, updated_at="2026-10-08T18:01:00Z")
            last["base"]["sha"] = "unrelated-main-commit"
            last["base"]["repo"]["pushed_at"] = "2026-10-08T18:01:00Z"
            last["user"]["login"] = "CONTRIBUTOR"
            api = FakeApi(first, issue(), last) if valid else FakeApi(first, last)
            self.assertEqual(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0], valid)

    def test_real_policy_field_changes_abort_the_decision(self):
        changes = [
            ("number", 24), ("created_at", "2026-10-08T18:00:01Z"), ("user.login", "other-author"), ("user.id", 42),
            ("head.sha", "new-head"), ("head.ref", "new-ref"), ("head.repo.full_name", "other/fork"),
            ("head.repo.id", 43), ("base.ref", "release"), ("base.repo.full_name", "other/repo"), ("base.repo.id", 44),
        ]
        for path, value in changes:
            for valid in (False, True):
                with self.subTest(path=path, valid=valid):
                    first = pull() if valid else pull(body="")
                    last = copy.deepcopy(first)
                    parts = path.split(".")
                    node = last
                    for part in parts[:-1]:
                        node = node[part]
                    node[parts[-1]] = value
                    api = FakeApi(first, issue(), last) if valid else FakeApi(first, last)
                    with self.assertRaisesRegex(policy.PolicyError, "changed during"):
                        policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)

    def test_malformed_recheck_data_fails_closed(self):
        for path, value in (
            ("user", None), ("user", {}), ("head", []), ("base", "bad"), ("head.repo", []),
            ("number", 23.0), ("merged", 0),
        ):
            with self.subTest(path=path):
                last = pull()
                parts = path.split(".")
                node = last
                for part in parts[:-1]:
                    node = node[part]
                node[parts[-1]] = value
                with self.assertRaises(policy.PolicyError):
                    policy.check_policy(FakeApi(pull(), issue(), last), REPOSITORY, 23, ACTIVATED_AT)

    def test_checkbox_after_a_list_or_quote_needs_its_own_block(self):
        for prefix in ("- Example:", "1. Example:", "> Example:", "  - Example:", "- [ ] Example task:"):
            with self.subTest(prefix=prefix):
                body = NO_AGENT.replace(TEST_CONFIRMATION, prefix + "\n" + TEST_CONFIRMATION)
                self.assertIsNotNone(policy.body_requirement(body))
                public = NO_AGENT.replace(TEST_CONFIRMATION, prefix + "\n\n" + TEST_CONFIRMATION)
                self.assertIsNone(policy.body_requirement(public))
        public = NO_AGENT.replace(TEST_CONFIRMATION, "- Example:\n## Tests\n" + TEST_CONFIRMATION)
        self.assertIsNone(policy.body_requirement(public))


class ParserTests(unittest.TestCase):
    def test_supported_lines_and_duplicates(self):
        body = "Closes #7\nfixes #7\nResolves https://github.com/OWNER/REPO/issues/8  "
        self.assertEqual(policy.issue_references(body, REPOSITORY), [7, 8])

    def test_only_complete_plain_lines_count(self):
        examples = [
            "Related to #7", "Closes #7 because it fails", "- Closes #7", "> Fixes #7", "`Closes #7`",
            "    Closes #7", "\tCloses #7", "Closes #0", "Closes #07", "Closes #7, #8",
            " Closes #7", "  Closes #7", "   Closes #7",
            "Closes other/repo#7", "Closes https://github.com/other/repo/issues/7",
            "Closes http://github.com/owner/repo/issues/7", "Closes https://github.com/owner/repo/pull/7",
            "Closes https://github.com/owner/repo/issues/7?x=1", "[Closes #7](https://example.com)",
        ]
        for body in examples:
            with self.subTest(body=body):
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])

    def test_comments_and_code_do_not_count(self):
        examples = [
            "<!-- Closes #7 -->", "<!--\nCloses #7\n-->", "<!--\nCloses #7",
            "```text\nCloses #7\n```", "~~~\nCloses #7\n~~~", "   ```\nCloses #7\n   ```",
            "````\n```\nCloses #7\n```\n````", "Closes <!-- example -->#7",
        ]
        for body in examples:
            with self.subTest(body=body):
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
        self.assertEqual(policy.issue_references("```\nCloses #7\n```\nCloses #8", REPOSITORY), [8])

    def test_limit_bounds_api_reads(self):
        body = "\n".join(f"Closes #{number}" for number in range(1, 22))
        with self.assertRaises(policy.PolicyError):
            policy.issue_references(body, REPOSITORY)

    def test_body_size_is_bounded(self):
        with self.assertRaisesRegex(policy.PolicyError, "size limit"):
            policy.plain_lines("x" * (128 * 1024 + 1))

    def test_ai_records_and_no_agent_statement_pass(self):
        second_agent = "\n\nHarness: Hermes Agent\nModel: example-model-v1\nWork: Diagnose a synthetic failure.\n"
        for body in (NO_AGENT, AGENT_USE, AGENT_USE + second_agent):
            with self.subTest(body=body):
                self.assertIsNone(policy.body_requirement(body))
        concrete_work = AGENT_USE.replace("Write policy tests.", "Replace [x] parser logic.")
        self.assertIsNone(policy.body_requirement(concrete_work))

    def test_agent_record_count_is_bounded(self):
        records = "Harness: Codex\nModel: gpt-6.1-sol\nWork: Write policy tests.\n"
        body = "## AI agent use\n" + records * 21 + TEST_CONFIRMATION
        self.assertIn("at most 20", policy.body_requirement(body))

    def test_ai_section_is_required_and_has_a_boundary(self):
        examples = [
            "No AI agent used\n" + TEST_CONFIRMATION,
            "## AI agent use\n## Tests\nNo AI agent used\n" + TEST_CONFIRMATION,
            NO_AGENT + "\n## AI agent use\nNo AI agent used",
            "## AI Agent Use\nNo AI agent used\n" + TEST_CONFIRMATION,
        ]
        for body in examples:
            with self.subTest(body=body):
                self.assertIsNotNone(policy.body_requirement(body))

    def test_no_agent_statement_is_exact_and_cannot_mix_with_records(self):
        for statement in ("no AI agent used", "No AI agent used.", "- No AI agent used", "> No AI agent used"):
            with self.subTest(statement=statement):
                self.assertIsNotNone(policy.body_requirement(NO_AGENT.replace("No AI agent used", statement)))
        self.assertIsNotNone(policy.body_requirement(AGENT_USE + "\n\nNo AI agent used"))

    def test_each_record_requires_all_fields_and_real_values(self):
        for field, value in (("Harness", "Codex"), ("Model", "gpt-6.1-sol"), ("Work", "Write policy tests.")):
            for replacement in ("", "...", "TODO", "<value>", "[value]", "unknown", "enter value"):
                with self.subTest(field=field, replacement=replacement):
                    body = AGENT_USE.replace(f"{field}: {value}", f"{field}: {replacement}")
                    self.assertIsNotNone(policy.body_requirement(body))
            with self.subTest(missing=field):
                self.assertIsNotNone(policy.body_requirement(AGENT_USE.replace(f"{field}: {value}\n", "")))
        self.assertIsNotNone(policy.body_requirement(AGENT_USE + "\n\nHarness: Hermes Agent"))

    def test_disclosure_in_comments_or_code_does_not_count(self):
        section = "## AI agent use\nNo AI agent used"
        for hidden in (
            "<!--\n" + section + "\n-->", "```text\n" + section + "\n```",
            "~~~\n" + section + "\n~~~", "    ## AI agent use\n    No AI agent used",
            " \t## AI agent use\n \tNo AI agent used",
        ):
            with self.subTest(hidden=hidden):
                self.assertIsNotNone(policy.body_requirement(hidden + "\n" + TEST_CONFIRMATION))
        hidden_model = AGENT_USE.replace("Model: gpt-6.1-sol", "<!-- Model: gpt-6.1-sol -->")
        self.assertIsNotNone(policy.body_requirement(hidden_model))

    def test_comments_cannot_turn_code_text_into_assertions(self):
        for end in ("-->", "--!>"):
            with self.subTest(end=end):
                body = f"```text\n<!-- example {end}```\n" + NO_AGENT + "\n```"
                self.assertIsNotNone(policy.body_requirement(body))
                body = f"```text\n<!-- example {end}```\nCloses #7\n```"
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(f"```text <!-- example {end}\n" + NO_AGENT + "\n```"))
                self.assertIsNone(policy.body_requirement(f"<!--\n```\n{end}\n" + NO_AGENT))

    def test_both_html_comment_end_tags_restore_public_lines(self):
        for end in ("-->", "--!>"):
            with self.subTest(end=end):
                body = f"Closes #6\n<!--\nCloses #7\n{end}\nCloses #8"
                self.assertEqual(policy.issue_references(body, REPOSITORY), [6, 8])
                hidden = "<!--\n" + NO_AGENT + f"\n{end}"
                self.assertIsNotNone(policy.body_requirement(hidden))
                self.assertIsNone(policy.body_requirement(NO_AGENT + "\n\n" + hidden))
                self.assertIsNone(policy.body_requirement(hidden + "\n\n" + NO_AGENT))
                hidden_ai = f"<!--\n## AI agent use\nNo AI agent used\n{end}\n" + TEST_CONFIRMATION
                self.assertIsNotNone(policy.body_requirement(hidden_ai))
                hidden_test = f"## AI agent use\nNo AI agent used\n<!--\n{TEST_CONFIRMATION}\n{end}"
                self.assertIsNotNone(policy.body_requirement(hidden_test))
                self.assertEqual(policy.issue_references(f"<!-- example {end}Closes #7", REPOSITORY), [])

    def test_multiline_inline_code_does_not_count(self):
        for marker in ("`", "``"):
            with self.subTest(marker=marker):
                self.assertEqual(policy.issue_references(marker + "\nCloses #7\n" + marker, REPOSITORY), [])
                self.assertIsNone(policy.body_requirement(marker + "\n" + NO_AGENT + "\n" + marker))
                visible = marker + "\nexample\n" + marker + "\n\n" + NO_AGENT
                self.assertIsNone(policy.body_requirement(visible))
        self.assertEqual(policy.issue_references("`\n` text `\nCloses #7\n`", REPOSITORY), [])

    def test_html_code_blocks_do_not_count(self):
        for tag in ("pre", "code", "script", "style", "textarea", "PRE"):
            with self.subTest(tag=tag):
                body = f'<{tag} class="example">\nCloses #7\n{NO_AGENT}\n</{tag}>'
                self.assertEqual(policy.issue_references(body, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(body))
                self.assertIsNone(policy.body_requirement(body + "\n\n" + NO_AGENT))
        self.assertIsNotNone(policy.body_requirement("<pre>\n</pre><pre>\n" + NO_AGENT + "\n</pre>"))
        self.assertIsNotNone(policy.body_requirement("<pre\n>\n" + NO_AGENT + "\n</pre>"))

    def test_nested_html_code_stays_hidden_until_the_outer_close(self):
        for outer, inner in (("code", "code"), ("code", "pre"), ("pre", "code")):
            with self.subTest(outer=outer, inner=inner):
                hidden = f"<{outer}><{inner}>\nexample\n</{inner}>\nCloses #7\n{NO_AGENT}\n</{outer}>"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_comment_tags_cannot_close_or_hide_an_html_code_block(self):
        for end in ("-->", "--!>"):
            for opening in (f"<code>\n<!--\n</code>\n{end}", f"<code><!-- </code> {end}"):
                with self.subTest(end=end, opening=opening):
                    hidden = opening + "\nCloses #7\n" + NO_AGENT + "\n</code>"
                    self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                    self.assertIsNotNone(policy.body_requirement(hidden))
                    public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                    self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                    self.assertIsNone(policy.body_requirement(public))

    def test_quoted_html_attributes_cannot_end_code_or_start_comments(self):
        examples = (
            '<code><span title="</code>">', "<code><span title='</code>'>",
            '<code><span\ntitle="\n</code>\n">', "<code><span\ntitle='\n</code>\n'>",
            '<code><span title="</code><!--">',
        )
        for opening in examples:
            with self.subTest(opening=opening):
                hidden = opening + "\nCloses #7\n" + NO_AGENT + "\n</span></code>"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_html_quote_and_list_containers_do_not_count(self):
        for tag in ("blockquote", "ul", "ol", "li", "dl"):
            with self.subTest(tag=tag):
                hidden = f"<{tag}>\nCloses #7\n{NO_AGENT}\n</{tag}>"
                self.assertEqual(policy.issue_references(hidden, REPOSITORY), [])
                self.assertIsNotNone(policy.body_requirement(hidden))
                public = hidden + "\n\nCloses #8\n\n" + NO_AGENT
                self.assertEqual(policy.issue_references(public, REPOSITORY), [8])
                self.assertIsNone(policy.body_requirement(public))

    def test_list_and_quote_continuations_do_not_count(self):
        for prefix in ("- Example:", "1. Example:", "> Example:", "  - Example:", "  > Example:"):
            for indent in ("", "  "):
                with self.subTest(prefix=prefix, indent=indent):
                    self.assertEqual(policy.issue_references(prefix + "\n" + indent + "Closes #7", REPOSITORY), [])
        self.assertEqual(policy.issue_references("- Example:\n\nCloses #7", REPOSITORY), [7])
        self.assertIsNotNone(policy.body_requirement("- Example:\n  " + NO_AGENT.replace("\n", "\n  ")))

    def test_test_confirmation_must_be_visible_exact_and_checked(self):
        examples = [
            "", TEST_CONFIRMATION.replace("[x]", "[ ]"), TEST_CONFIRMATION.replace("all passed.", "all passed"),
            TEST_CONFIRMATION + " except one.", "<!-- " + TEST_CONFIRMATION + " -->",
            "```\n" + TEST_CONFIRMATION + "\n```", "~~~\n" + TEST_CONFIRMATION + "\n~~~",
            "    " + TEST_CONFIRMATION, " \t" + TEST_CONFIRMATION, "> " + TEST_CONFIRMATION,
        ]
        for line in examples:
            with self.subTest(line=line):
                reason = policy.body_requirement(NO_AGENT.replace(TEST_CONFIRMATION, line))
                self.assertIn("checked line", reason)
        self.assertIsNone(policy.body_requirement(NO_AGENT.replace("[x]", "[X]")))


class DecisionTests(unittest.TestCase):
    def check(self, api):
        return policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)

    def test_older_issue_passes_and_pr_is_fetched_again(self):
        api = FakeApi(pull(), issue(), pull())
        passed, message = self.check(api)
        self.assertTrue(passed)
        self.assertIn("#7", message)
        self.assertEqual(api.paths, [PR_PATH, "/repos/owner/repo/issues/7", PR_PATH])

    def test_closed_issue_and_different_author_pass(self):
        api = FakeApi(pull(), issue(state="closed"), pull())
        self.assertTrue(self.check(api)[0])

    def test_equal_or_later_issue_fails(self):
        for created_at in ("2026-10-08T18:00:00Z", "2026-10-08T18:00:01Z"):
            with self.subTest(created_at=created_at):
                api = FakeApi(pull(), issue(created_at=created_at), pull())
                self.assertFalse(self.check(api)[0])

    def test_pr_is_not_an_issue(self):
        api = FakeApi(pull(), issue(pull_request={}, html_url="https://github.com/owner/repo/pull/7"), pull())
        self.assertFalse(self.check(api)[0])

    def test_missing_issue_is_confirmed_invalid(self):
        api = FakeApi(pull(), policy.ApiError(404), pull())
        self.assertFalse(self.check(api)[0])

    def test_missing_and_external_references_fail_without_issue_reads(self):
        for body in (None, "", "Closes https://github.com/another/repo/issues/7", "<!-- Closes #7 -->"):
            with self.subTest(body=body):
                data = pull(body=(body or "") + "\n\n" + NO_AGENT)
                api = FakeApi(data, data)
                self.assertFalse(self.check(api)[0])
                self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_any_one_valid_issue_passes(self):
        data = pull(body="Closes #7\nFixes #8\n\n" + NO_AGENT)
        api = FakeApi(data, policy.ApiError(404), issue(8), data)
        self.assertTrue(self.check(api)[0])

    def test_api_errors_abort_the_decision(self):
        cases = [
            (policy.ApiError(403),),
            (pull(), policy.ApiError(403)),
            (pull(), policy.ApiError(429)),
            (pull(), policy.ApiError(500)),
            (pull(), policy.ApiError()),
            (pull(), issue(), policy.ApiError(500)),
        ]
        for replies in cases:
            with self.subTest(replies=len(replies)):
                with self.assertRaises(policy.ApiError):
                    self.check(FakeApi(*replies))

    def test_bad_issue_data_aborts_the_decision(self):
        cases = [issue(number=8), issue(created_at=None), issue(html_url="https://github.com/other/repo/issues/7")]
        for data in cases:
            with self.subTest(data=data):
                with self.assertRaises(policy.PolicyError):
                    self.check(FakeApi(pull(), data))

    def test_changed_pr_aborts_both_pass_and_fail(self):
        changes = [
            {"body": "Closes #8"}, {"state": "closed"}, {"merged": True},
            {"head": {"sha": "new-head"}}, {"base": {"ref": "release", "repo": {"full_name": REPOSITORY}}},
            {"user": {"login": "Elevatormusic"}},
        ]
        for change in changes:
            for valid in (False, True):
                with self.subTest(change=change, valid=valid):
                    first = pull() if valid else pull(body="")
                    last = copy.deepcopy(first)
                    last.update(change)
                    api = FakeApi(first, issue(), last) if valid else FakeApi(first, last)
                    with self.assertRaisesRegex(policy.PolicyError, "changed during"):
                        self.check(api)

    def test_mergeability_calculation_does_not_change_the_policy(self):
        api = FakeApi(pull(mergeable=None), issue(), pull(mergeable=True))
        self.assertTrue(self.check(api)[0])

    def test_closed_or_merged_pr_is_skipped(self):
        for change in ({"state": "closed"}, {"merged": True}):
            api = FakeApi(pull(**change))
            self.assertTrue(self.check(api)[0])
            self.assertEqual(api.paths, [PR_PATH])

    def test_old_pr_is_skipped_even_with_current_edits(self):
        data = pull(created_at="2026-10-08T17:09:41Z", body=None, updated_at="2026-10-09T00:00:00Z")
        api = FakeApi(data)
        self.assertTrue(self.check(api)[0])
        self.assertEqual(api.paths, [PR_PATH])

    def test_owner_is_exempt_only_from_the_issue_requirement(self):
        for login in ("Elevatormusic", "ELEVATORMUSIC", "eLeVaToRmUsIc"):
            with self.subTest(login=login):
                data = pull(user={"login": login}, body=NO_AGENT)
                api = FakeApi(data, data)
                self.assertTrue(self.check(api)[0])
                self.assertEqual(api.paths, [PR_PATH, PR_PATH])
        for body in ("", "## AI agent use\nNo AI agent used", TEST_CONFIRMATION):
            with self.subTest(body=body):
                data = pull(user={"login": "Elevatormusic"}, body=body)
                self.assertFalse(self.check(FakeApi(data, data))[0])

    def test_owner_association_and_fork_owner_cannot_exempt_a_contributor(self):
        data = pull(
            body=NO_AGENT, author_association="OWNER",
            head={"repo": {"full_name": "Elevatormusic/fork", "owner": {"login": "Elevatormusic"}}},
        )
        api = FakeApi(data, data)
        self.assertFalse(self.check(api)[0])
        self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_body_requirements_fail_before_issue_reads(self):
        for body in ("Closes #7", "Closes #7\n## AI agent use\nNo AI agent used"):
            with self.subTest(body=body):
                data = pull(body=body)
                api = FakeApi(data, data)
                passed, reason = self.check(api)
                self.assertFalse(passed)
                self.assertTrue(reason)
                self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_agent_disclosure_does_not_replace_a_contributor_issue(self):
        data = pull(body=AGENT_USE)
        api = FakeApi(data, data)
        self.assertFalse(self.check(api)[0])
        self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_author_race_aborts_owner_exemption(self):
        data = pull(user={"login": "Elevatormusic"}, body=NO_AGENT)
        changed = pull(user={"login": "contributor"}, body=NO_AGENT)
        with self.assertRaisesRegex(policy.PolicyError, "changed during"):
            self.check(FakeApi(data, changed))

    def test_pr_at_activation_is_checked(self):
        data = pull(created_at=ACTIVATED_AT, body="")
        api = FakeApi(data, data)
        self.assertFalse(self.check(api)[0])

    def test_missing_or_invalid_activation_fails_before_api_reads(self):
        for activated_at in (None, "", "invalid", "2026-10-08T17:09:42", "2026-02-30T17:09:42Z"):
            with self.subTest(activated_at=activated_at):
                api = FakeApi()
                with self.assertRaisesRegex(policy.PolicyError, "timestamp"):
                    policy.check_policy(api, REPOSITORY, 23, activated_at)
                self.assertEqual(api.paths, [])

    def test_malformed_pr_and_timestamp_fail(self):
        for data in (
            pull(number=24), pull(merged="false"), pull(created_at="invalid"), pull(base={}),
            pull(user={}), pull(user={"login": ""}), pull(user={"login": None}),
        ):
            with self.subTest(data=data):
                with self.assertRaises(policy.PolicyError):
                    self.check(FakeApi(data))


class EntryTests(unittest.TestCase):
    def run_main(self, event_name, event, api):
        with tempfile.TemporaryDirectory() as folder:
            event_path = Path(folder) / "event.json"
            event_path.write_text(json.dumps(event), encoding="utf-8")
            env = {
                "GITHUB_REPOSITORY": REPOSITORY,
                "GITHUB_EVENT_PATH": str(event_path),
                "GITHUB_EVENT_NAME": event_name,
                "GITHUB_TOKEN": "fake-test-token",
                "ISSUE_POLICY_ACTIVATED_AT": ACTIVATED_AT,
            }
            output = io.StringIO()
            with patch.dict(os.environ, env, clear=True), patch.object(policy, "GitHubApi", return_value=api):
                with redirect_stdout(output):
                    result = policy.main()
            self.assertNotIn("fake-test-token", output.getvalue())
            return result, output.getvalue()

    def test_old_pr_remains_exempt_for_every_event(self):
        for action in ("opened", "reopened", "edited", "synchronize", "ready_for_review"):
            with self.subTest(action=action):
                api = FakeApi(pull(created_at="2026-10-08T17:09:41Z", body=""))
                result, _ = self.run_main("pull_request_target", {"action": action, "number": 23}, api)
                self.assertEqual(result, 0)
                self.assertEqual(api.paths, [PR_PATH])

    def test_dispatch_reads_fresh_pr_and_never_writes(self):
        data = pull(body="")
        api = FakeApi(data, data)
        result, output = self.run_main("workflow_dispatch", {"inputs": {"pr_number": "23"}}, api)
        self.assertEqual(result, 1)
        self.assertTrue(output.startswith("::error::"))
        self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_event_body_is_never_used_as_current_data(self):
        api = FakeApi(pull(), issue(), pull())
        result, _ = self.run_main(
            "pull_request_target", {"action": "opened", "number": 23, "pull_request": {"body": "bad"}}, api
        )
        self.assertEqual(result, 0)

    def test_event_actor_and_event_author_cannot_exempt_a_contributor(self):
        data = pull(body=NO_AGENT)
        api = FakeApi(data, data)
        result, _ = self.run_main(
            "pull_request_target",
            {"action": "opened", "number": 23, "sender": {"login": "Elevatormusic"},
             "pull_request": {"user": {"login": "Elevatormusic"}, "body": "Closes #7"}},
            api,
        )
        self.assertEqual(result, 1)
        self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_fresh_api_owner_controls_exemption(self):
        data = pull(user={"login": "Elevatormusic"}, body=AGENT_USE)
        api = FakeApi(data, data)
        result, _ = self.run_main(
            "pull_request_target",
            {"action": "opened", "number": 23, "sender": {"login": "contributor"},
             "pull_request": {"user": {"login": "contributor"}}},
            api,
        )
        self.assertEqual(result, 0)
        self.assertEqual(api.paths, [PR_PATH, PR_PATH])

    def test_bad_dispatch_input_and_unsupported_events_fail_before_api(self):
        cases = [
            ("workflow_dispatch", {"inputs": {"pr_number": "23; echo unsafe"}}),
            ("workflow_dispatch", {"inputs": {"pr_number": "-1"}}),
            ("workflow_dispatch", {"inputs": {"pr_number": True}}),
            ("pull_request", {"action": "opened", "number": 23}),
            ("pull_request_target", {"action": "closed", "number": 23}),
        ]
        for event_name, event in cases:
            with self.subTest(event_name=event_name, event=event):
                api = FakeApi()
                self.assertEqual(self.run_main(event_name, event, api)[0], 1)
                self.assertEqual(api.paths, [])


class TransportTests(unittest.TestCase):
    def reply(self, raw):
        class Response:
            def __enter__(self):
                return self

            def __exit__(self, *args):
                return None

            def read(self, limit):
                return raw[:limit]

        return Response()

    def test_large_issue_bodies_allow_five_prs_with_smaller_pages(self):
        items = [issue(number, user={"login": "contributor"}, body="x" * 65536) for number in range(100, 124)]
        items += [open_pull(number) for number in (23, 24, 25, 26, 27)]
        requests = []
        api = policy.GitHubApi("fake-test-token")

        def reply(request, timeout):
            parsed = urlsplit(request.full_url)
            if parsed.query:
                query = parse_qs(parsed.query)
                size, page = int(query["per_page"][0]), int(query["page"][0])
                requests.append((size, page))
                result = items[(page - 1) * size:page * size]
            else:
                result = pull() if parsed.path == PR_PATH else issue()
            return self.reply(json.dumps(result).encode())

        with patch.object(api.opener, "open", side_effect=reply):
            self.assertTrue(policy.check_policy(api, REPOSITORY, 23, ACTIVATED_AT)[0])
        self.assertEqual(requests, [(100, 1), (50, 1), (25, 1), (12, 1), (12, 2), (12, 3)] * 2)

    def test_one_oversized_item_refuses_with_fixed_transport_limit(self):
        raw = json.dumps([issue(100, user={"login": "contributor"}, body="x" * (1024 * 1024))]).encode()
        reads = []

        class Response:
            def __enter__(self):
                return self

            def __exit__(self, *args):
                return None

            def read(self, limit):
                reads.append(limit)
                return raw[:limit]

        api = policy.GitHubApi("fake-test-token")
        with patch.object(api.opener, "open", return_value=Response()) as opened:
            with self.assertRaisesRegex(policy.PolicyError, "size limit.*unknown"):
                policy.author_open_pulls(api, REPOSITORY, "contributor", 23)
        self.assertEqual(opened.call_count, 7)
        self.assertEqual(reads, [1024 * 1024 + 1] * 7)

    def test_oversized_dict_response_is_typed_without_retry(self):
        api = policy.GitHubApi("fake-test-token")
        with patch.object(api.opener, "open", return_value=self.reply(b"x" * (1024 * 1024 + 1))) as opened:
            with self.assertRaises(policy.ResponseTooLarge):
                api.get(PR_PATH)
        self.assertEqual(opened.call_count, 1)

    def test_request_is_a_get_to_the_fixed_host(self):
        api = policy.GitHubApi("fake-test-token")
        with patch.object(api.opener, "open", return_value=self.reply(b'{"number": 7}')) as opened:
            self.assertEqual(api.get("/repos/owner/repo/issues/7"), {"number": 7})
        request = opened.call_args.args[0]
        self.assertEqual(request.full_url, "https://api.github.com/repos/owner/repo/issues/7")
        self.assertEqual(request.get_method(), "GET")
        self.assertIsNone(request.data)
        self.assertEqual(opened.call_args.kwargs, {"timeout": 30})

    def test_http_and_network_errors_are_safe_and_do_not_log_response_data(self):
        errors = [
            HTTPError("https://api.github.com", 403, "private-body", {}, None),
            URLError("private-url-or-token"), TimeoutError("private-url-or-token"),
        ]
        for error in errors:
            with self.subTest(kind=type(error).__name__):
                api = policy.GitHubApi("fake-test-token")
                with patch.object(api.opener, "open", side_effect=error):
                    with self.assertRaises(policy.ApiError) as raised:
                        api.get(PR_PATH)
                self.assertNotIn("private", str(raised.exception))
                self.assertNotIn("fake-test-token", str(raised.exception))

    def test_invalid_json_and_large_response_fail(self):
        for raw in (b"not-json", b"[]", b"x" * (1024 * 1024 + 1)):
            with self.subTest(size=len(raw)):
                api = policy.GitHubApi("fake-test-token")
                with patch.object(api.opener, "open", return_value=self.reply(raw)):
                    with self.assertRaises(policy.ApiError):
                        api.get(PR_PATH)

    def test_list_request_keeps_the_fixed_host_and_does_not_weaken_dict_checks(self):
        api = policy.GitHubApi("fake-test-token")
        path = "/repos/owner/repo/issues?state=open&creator=contributor&per_page=100&page=1"
        with patch.object(api.opener, "open", return_value=self.reply(b'[{"number": 23}]')) as opened:
            self.assertEqual(api.get_list(path), [{"number": 23}])
        request = opened.call_args.args[0]
        self.assertEqual(request.full_url, "https://api.github.com" + path)
        self.assertEqual(request.get_method(), "GET")
        self.assertIsNone(request.data)
        self.assertEqual(opened.call_args.kwargs, {"timeout": 30})
        with patch.object(api.opener, "open", return_value=self.reply(b'[{"number": 23}]')):
            with self.assertRaises(policy.ApiError):
                api.get(PR_PATH)

    def test_list_invalid_json_type_items_size_and_api_errors_fail(self):
        for raw in (b"not-json", b"{}", b"null", b"[null]", b"[true]", b'["item"]',
                    json.dumps([{}] * 101).encode(), b"x" * (1024 * 1024 + 1)):
            with self.subTest(size=len(raw)):
                api = policy.GitHubApi("fake-test-token")
                with patch.object(api.opener, "open", return_value=self.reply(raw)):
                    with self.assertRaises(policy.ApiError):
                        api.get_list("/repos/owner/repo/issues")
        for error in (HTTPError("https://api.github.com", 500, "private-body", {}, None),
                      URLError("private-url-or-token"), TimeoutError("private-url-or-token")):
            api = policy.GitHubApi("fake-test-token")
            with patch.object(api.opener, "open", side_effect=error):
                with self.assertRaises(policy.ApiError) as raised:
                    api.get_list("/repos/owner/repo/issues")
            self.assertNotIn("private", str(raised.exception))
            self.assertNotIn("fake-test-token", str(raised.exception))

    def test_invalid_api_paths_fail_before_a_request(self):
        for path in ("@example.com", "//example.com/path", "https://example.com", "/repos/owner/repo\r\nunsafe"):
            for method in ("get", "get_list"):
                with self.subTest(path=path, method=method):
                    api = policy.GitHubApi("fake-test-token")
                    with patch.object(api.opener, "open") as opened:
                        with self.assertRaises(policy.ApiError):
                            getattr(api, method)(path)
                        opened.assert_not_called()

    def test_redirects_are_not_followed(self):
        self.assertIsNone(policy.NoRedirect().redirect_request(None, None, 302, "", {}, "https://example.com"))


if __name__ == "__main__":
    unittest.main()