imbad0202__academic-research-skills/scripts/test_tortured_phrase_screening.py

"""Hermetic conformance and mutation tests for issue #660."""
from __future__ import annotations

import copy
import hashlib
import json
import subprocess
import sys
import unicodedata
from collections import Counter
from pathlib import Path

import pytest
import yaml
from jsonschema import Draft202012Validator


SCRIPTS = Path(__file__).resolve().parent
REPO_ROOT = SCRIPTS.parent
FIXTURES = SCRIPTS / "fixtures/tortured_phrase_screening"
sys.path.insert(0, str(SCRIPTS))

import tortured_phrase_screening as screening  # noqa: E402


CHECKED_AT = "2026-08-10T01:00:00Z"
RECORDED_AT = "2026-08-10T01:00:01Z"


def _bundle() -> screening.SnapshotBundle:
    return screening.load_snapshot(
        FIXTURES / "snapshot.json", FIXTURES / "snapshot_manifest.json"
    )


def _state() -> screening.SnapshotState:
    bundle = _bundle()
    return screening.SnapshotState(
        status="loaded",
        reason_code="CHECK_COMPLETED",
        bundle=bundle,
        snapshot_sha256=bundle.snapshot_sha256,
        manifest_sha256=bundle.manifest_sha256,
        detail=None,
    )


def _draft(name: str) -> str:
    return (FIXTURES / name).read_text(encoding="utf-8")


def _report(name: str = "own_draft.md") -> dict:
    return screening.build_own_draft_report(
        _draft(name),
        artifact_id=name,
        artifact_format="latex" if name.endswith(".tex") else "markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )


def _passport() -> dict:
    return yaml.safe_load((FIXTURES / "corpus_input.yaml").read_text(encoding="utf-8"))


def _enriched(state: screening.SnapshotState | None = None) -> dict:
    return screening.enrich_passport(
        _passport(),
        state=state or _state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )


def _seed_expectations() -> dict:
    value, _raw = screening._strict_json_path(
        FIXTURES / "seed_expectations.json",
        label="synthetic seed expectations",
        maximum=512 * 1024,
    )
    if not isinstance(value, dict):
        raise AssertionError("seed expectations root must be an object")
    return value


def _expect_exact_keys(
    value: object,
    *,
    required: set[str],
    optional: set[str] | None = None,
    label: str,
) -> dict:
    if not isinstance(value, dict):
        raise AssertionError(f"{label} must be an object")
    optional = optional or set()
    keys = set(value)
    if keys != required | (keys & optional):
        missing = required - keys
        unknown = keys - required - optional
        raise AssertionError(
            f"{label} keys drifted; missing={sorted(missing)!r}, "
            f"unknown={sorted(unknown)!r}"
        )
    return value


def _compiled_rules() -> dict[str, screening.CompiledRule]:
    return {rule.rule_id: rule for rule in _bundle().rules}


def _actual_suppressions(
    text: str,
    segments: list[screening.Segment],
    rules: dict[str, screening.CompiledRule],
) -> Counter[tuple[str, str]]:
    suppressed: Counter[tuple[str, str]] = Counter()
    for segment in segments:
        tokens = screening.tokenize(text[segment.start : segment.end])
        for rule in rules.values():
            included = set(screening.evaluate_expression(rule.expression, tokens))
            retained = set(screening.evaluate_rule(rule, tokens))
            suppressed[(rule.rule_id, segment.kind)] += len(included - retained)
    return +suppressed


def _has_token_boundary_negative(
    rule: screening.CompiledRule,
    text: str,
    segments: list[screening.Segment],
) -> bool:
    expression = rule.expression
    if expression.get("op") != "literal":
        return False
    literal_tokens = screening.tokenize(expression["value"])
    if len(literal_tokens) != 1:
        return False
    literal = literal_tokens[0].normalized
    return any(
        literal in token.normalized and literal != token.normalized
        for segment in segments
        for token in screening.tokenize(text[segment.start : segment.end])
    )


def _has_same_segment_exclusion(
    rule: screening.CompiledRule,
    text: str,
    segments: list[screening.Segment],
) -> bool:
    if not rule.exclude_if:
        return False
    for segment in segments:
        tokens = screening.tokenize(text[segment.start : segment.end])
        included = set(screening.evaluate_expression(rule.expression, tokens))
        if included and included - set(screening.evaluate_rule(rule, tokens)):
            return True
    return False


def _non_match_reason_holds(
    reason: str,
    rule: screening.CompiledRule,
    text: str,
    segments: list[screening.Segment],
) -> bool:
    if reason == "token_boundary":
        return _has_token_boundary_negative(rule, text, segments)
    if reason == "exclude_if_in_same_segment":
        return _has_same_segment_exclusion(rule, text, segments)
    raise AssertionError(f"unsupported synthetic non-match reason {reason!r}")


def _normalization_case_holds(
    case: str,
    match: dict,
    rule: screening.CompiledRule,
) -> bool:
    expression = rule.expression
    if expression.get("op") != "literal":
        return False
    raw = match["matched_text"]
    actual_tokens = tuple(token.normalized for token in screening.tokenize(raw))
    literal_tokens = tuple(
        token.normalized for token in screening.tokenize(expression["value"])
    )
    if actual_tokens != literal_tokens:
        return False
    if case == "nfkc_casefold":
        folded = unicodedata.normalize("NFKC", raw).casefold()
        return folded == expression["value"].casefold() and raw.casefold() != folded
    if case == "same_line_dash_separator":
        return "\n" not in raw and any(char in screening._DASHES for char in raw)
    if case == "soft_hyphen_join":
        return "\u00ad" in raw and "\n" not in raw
    if case == "line_break_hyphen_join":
        return any(
            char in screening._DASHES and index + 1 < len(raw) and raw[index + 1] == "\n"
            for index, char in enumerate(raw)
        )
    raise AssertionError(f"unsupported normalization case {case!r}")


def _alternative_matches_record(
    alternative: dict,
    match: dict,
    *,
    text: str,
    segments: dict[str, screening.Segment],
) -> bool:
    segment = segments[match["segment_id"]]
    tokens = screening.tokenize(text[segment.start : segment.end])
    span = match["source_span"]
    return any(
        segment.start + witness.codepoint_start == span["codepoint_start"]
        and segment.start + witness.codepoint_end == span["codepoint_end"]
        for witness in screening.evaluate_expression(alternative, tokens)
    )


def _spans_overlap(left: dict, right: dict) -> bool:
    if left["segment_id"] != right["segment_id"]:
        return False
    left_span = left["source_span"]
    right_span = right["source_span"]
    return max(left_span["codepoint_start"], right_span["codepoint_start"]) < min(
        left_span["codepoint_end"], right_span["codepoint_end"]
    )


def _replay_draft_expectation(
    expectation: dict,
    rules: dict[str, screening.CompiledRule],
) -> set[str]:
    expectation = _expect_exact_keys(
        expectation,
        required={
            "path",
            "expected_counts",
            "expected_matches",
            "expected_suppressions",
            "expected_non_matches",
        },
        label="draft expectation",
    )
    path = expectation["path"]
    if path not in {"own_draft.md", "own_draft.tex"}:
        raise AssertionError(f"unsupported draft expectation path {path!r}")
    text = _draft(path)
    artifact_format = "latex" if path.endswith(".tex") else "markdown"
    segments = screening.segment_document(text, artifact_format)
    segments_by_id = {segment.segment_id: segment for segment in segments}
    report = _report(path)
    if report["evaluation_status"] != "UNMEASURED":
        raise AssertionError(f"{path}: synthetic results must remain UNMEASURED")

    expected_counts = _expect_exact_keys(
        expectation["expected_counts"],
        required={
            "matched_rule_count",
            "rule_match_count",
            "unique_instance_count",
        },
        label=f"{path}.expected_counts",
    )
    for key, expected in expected_counts.items():
        if type(expected) is not int or expected < 0:
            raise AssertionError(f"{path}.expected_counts.{key} must be nonnegative int")
        if report["counts"][key] != expected:
            raise AssertionError(
                f"{path}.{key}: expected {expected}, got {report['counts'][key]}"
            )

    expected_match_counts: Counter[tuple[str, str]] = Counter()
    seen_match_keys: set[tuple[str, str]] = set()
    match_groups: dict[str, list[dict]] = {}
    group_by_match_id: dict[str, str | None] = {}
    normalization_cases: set[str] = set()
    for index, raw_expected in enumerate(expectation["expected_matches"]):
        expected = _expect_exact_keys(
            raw_expected,
            required={"rule_id", "count", "context"},
            optional={
                "matched_alternative_index",
                "overlap_group",
                "normalization_case",
            },
            label=f"{path}.expected_matches[{index}]",
        )
        rule_id = expected["rule_id"]
        context = expected["context"]
        count = expected["count"]
        if rule_id not in rules:
            raise AssertionError(f"{path}: unknown expected rule {rule_id!r}")
        if context not in screening.CONTEXTS:
            raise AssertionError(f"{path}: unknown expected context {context!r}")
        if type(count) is not int or count < 1:
            raise AssertionError(f"{path}: expected match count must be positive int")
        match_key = (rule_id, context)
        if match_key in seen_match_keys:
            raise AssertionError(f"{path}: duplicate expected match key {match_key!r}")
        seen_match_keys.add(match_key)
        expected_match_counts[match_key] = count
        actual_matches = [
            match
            for match in report["matches"]
            if (match["pattern_id"], match["context"]) == match_key
        ]

        expression = rules[rule_id].expression
        alternative_index = expected.get("matched_alternative_index")
        if expression.get("op") == "any":
            if type(alternative_index) is not int:
                raise AssertionError(f"{path}: any rule {rule_id!r} needs an alternative index")
            alternatives = expression["alternatives"]
            if not 0 <= alternative_index < len(alternatives):
                raise AssertionError(f"{path}: alternative index out of range")
            for match in actual_matches:
                matching_indexes = {
                    child_index
                    for child_index, alternative in enumerate(alternatives)
                    if _alternative_matches_record(
                        alternative,
                        match,
                        text=text,
                        segments=segments_by_id,
                    )
                }
                if matching_indexes != {alternative_index}:
                    raise AssertionError(
                        f"{path}: any alternative mismatch for {rule_id!r}: "
                        f"{sorted(matching_indexes)!r}"
                    )
        elif alternative_index is not None:
            raise AssertionError(f"{path}: non-any rule carries alternative index")

        overlap_group = expected.get("overlap_group")
        if overlap_group is not None and (
            not isinstance(overlap_group, str) or not overlap_group
        ):
            raise AssertionError(f"{path}: overlap_group must be a nonempty string")
        for match in actual_matches:
            group_by_match_id[match["match_id"]] = overlap_group
            if overlap_group is not None:
                match_groups.setdefault(overlap_group, []).append(match)

        normalization_case = expected.get("normalization_case")
        if normalization_case is not None:
            if not isinstance(normalization_case, str):
                raise AssertionError(f"{path}: normalization_case must be a string")
            normalization_cases.add(normalization_case)
            if not actual_matches or not all(
                _normalization_case_holds(normalization_case, match, rules[rule_id])
                for match in actual_matches
            ):
                raise AssertionError(
                    f"{path}: normalization case {normalization_case!r} did not replay"
                )

    actual_match_counts = Counter(
        (match["pattern_id"], match["context"]) for match in report["matches"]
    )
    if actual_match_counts != expected_match_counts:
        raise AssertionError(
            f"{path}: expected rule/context counts do not match runtime output"
        )

    for group, matches in match_groups.items():
        if len(matches) < 2 or screening._unique_instance_count(matches) != 1:
            raise AssertionError(f"{path}: overlap group {group!r} is not one component")
    for left_index, left in enumerate(report["matches"]):
        for right in report["matches"][left_index + 1 :]:
            if _spans_overlap(left, right) and (
                group_by_match_id.get(left["match_id"]) is None
                or group_by_match_id.get(left["match_id"])
                != group_by_match_id.get(right["match_id"])
            ):
                raise AssertionError(f"{path}: overlapping matches lack one shared group")

    expected_suppressions: Counter[tuple[str, str]] = Counter()
    for index, raw_expected in enumerate(expectation["expected_suppressions"]):
        expected = _expect_exact_keys(
            raw_expected,
            required={"rule_id", "count", "context", "reason"},
            label=f"{path}.expected_suppressions[{index}]",
        )
        rule_id = expected["rule_id"]
        count = expected["count"]
        context = expected["context"]
        if rule_id not in rules or not rules[rule_id].exclude_if:
            raise AssertionError(f"{path}: suppression names a non-excluding rule")
        if context not in screening.CONTEXTS:
            raise AssertionError(f"{path}: suppression context is unknown")
        if type(count) is not int or count < 1:
            raise AssertionError(f"{path}: suppression count must be positive int")
        if expected["reason"] != "exclude_if_within_token_window":
            raise AssertionError(f"{path}: unsupported suppression reason")
        key = (rule_id, context)
        if key in expected_suppressions:
            raise AssertionError(f"{path}: duplicate expected suppression {key!r}")
        expected_suppressions[key] = count
    if _actual_suppressions(text, segments, rules) != expected_suppressions:
        raise AssertionError(f"{path}: suppression oracle does not replay")

    non_match_reasons: set[str] = set()
    seen_non_matches: set[str] = set()
    for index, raw_expected in enumerate(expectation["expected_non_matches"]):
        expected = _expect_exact_keys(
            raw_expected,
            required={"rule_id", "reason"},
            label=f"{path}.expected_non_matches[{index}]",
        )
        rule_id = expected["rule_id"]
        reason = expected["reason"]
        if rule_id not in rules:
            raise AssertionError(f"{path}: non-match names unknown rule {rule_id!r}")
        if rule_id in seen_non_matches:
            raise AssertionError(f"{path}: duplicate non-match rule {rule_id!r}")
        seen_non_matches.add(rule_id)
        if any(match["pattern_id"] == rule_id for match in report["matches"]):
            raise AssertionError(f"{path}: expected non-match {rule_id!r} matched")
        if not _non_match_reason_holds(reason, rules[rule_id], text, segments):
            raise AssertionError(f"{path}: non-match reason {reason!r} did not replay")
        non_match_reasons.add(reason)
    return normalization_cases | {f"nonmatch:{reason}" for reason in non_match_reasons}


def _corpus_surface_text(entry: dict, surface: str) -> str | None:
    return entry["title"] if surface == "title" else entry.get("abstract")


def _replay_corpus_expectation(
    expectation: dict,
    rules: dict[str, screening.CompiledRule],
) -> set[str]:
    expectation = _expect_exact_keys(
        expectation,
        required={"path", "records"},
        label="corpus expectation",
    )
    if expectation["path"] != "corpus_input.yaml":
        raise AssertionError("corpus expectation path drifted")
    source_entries = {
        entry["citation_key"]: entry for entry in _passport()["literature_corpus"]
    }
    output_entries = {
        entry["citation_key"]: entry for entry in _enriched()["literature_corpus"]
    }
    records = expectation["records"]
    if not isinstance(records, list):
        raise AssertionError("corpus records must be an array")
    citation_keys = [
        record.get("citation_key") if isinstance(record, dict) else None
        for record in records
    ]
    if (
        any(not isinstance(key, str) or not key for key in citation_keys)
        or len(citation_keys) != len(set(citation_keys))
        or set(citation_keys) != set(source_entries)
        or set(citation_keys) != set(output_entries)
    ):
        raise AssertionError("corpus expectation citation inventory drifted")

    replayed_reasons: set[str] = set()
    surface_contexts = {"title": "cited_title", "abstract": "cited_abstract"}
    for record_index, raw_record in enumerate(records):
        record = _expect_exact_keys(
            raw_record,
            required={"citation_key", "surfaces"},
            label=f"corpus.records[{record_index}]",
        )
        citation_key = record["citation_key"]
        surfaces = _expect_exact_keys(
            record["surfaces"],
            required={"title", "abstract"},
            label=f"corpus.records[{citation_key}].surfaces",
        )
        source_entry = source_entries[citation_key]
        output_entry = output_entries[citation_key]
        signals = [
            signal
            for signal in output_entry["bibliographic_integrity_signals"]
            if signal.get("schema_version") == screening.SIGNAL_VERSION
            and signal.get("signal_type") == "tortured_phrase_match"
        ]
        if len(signals) != 2:
            raise AssertionError(
                f"{citation_key}: expected exactly the title and abstract signals"
            )
        for surface, context in surface_contexts.items():
            expected = _expect_exact_keys(
                surfaces[surface],
                required={"check_status", "reason", "expected_rule_ids"},
                optional={"non_match_reasons"},
                label=f"corpus.records[{citation_key}].{surface}",
            )
            matching_signals = [
                signal
                for signal in signals
                if signal["tortured_phrase_context"]["surface"] == context
            ]
            if len(matching_signals) != 1:
                raise AssertionError(
                    f"{citation_key}.{surface}: expected exactly one current signal"
                )
            signal = matching_signals[0]
            signal_context = signal["tortured_phrase_context"]
            if signal["check_status"] != expected["check_status"]:
                raise AssertionError(f"{citation_key}.{surface}: status drifted")
            if signal_context["reason_code"] != expected["reason"]:
                raise AssertionError(f"{citation_key}.{surface}: reason drifted")

            expected_rule_ids = expected["expected_rule_ids"]
            if (
                not isinstance(expected_rule_ids, list)
                or any(not isinstance(rule_id, str) for rule_id in expected_rule_ids)
                or len(expected_rule_ids) != len(set(expected_rule_ids))
                or any(rule_id not in rules for rule_id in expected_rule_ids)
            ):
                raise AssertionError(
                    f"{citation_key}.{surface}: expected_rule_ids are invalid"
                )
            actual_rule_ids = {
                match["pattern_id"] for match in signal_context["matches"]
            }
            if actual_rule_ids != set(expected_rule_ids):
                raise AssertionError(f"{citation_key}.{surface}: rule ids drifted")
            expected_finding = (
                "unresolved"
                if expected["check_status"] != "checked"
                else "detected" if expected_rule_ids else "not_detected"
            )
            if signal["finding"] != expected_finding:
                raise AssertionError(f"{citation_key}.{surface}: finding drifted")

            raw_non_matches = expected.get("non_match_reasons", [])
            if expected["check_status"] == "checked" and not expected_rule_ids:
                if not raw_non_matches:
                    raise AssertionError(
                        f"{citation_key}.{surface}: zero result lacks a rule-bound reason"
                    )
            text = _corpus_surface_text(source_entry, surface)
            seen_non_match_rules: set[str] = set()
            for reason_index, raw_reason in enumerate(raw_non_matches):
                reason_record = _expect_exact_keys(
                    raw_reason,
                    required={"rule_id", "reason"},
                    label=(
                        f"corpus.records[{citation_key}].{surface}."
                        f"non_match_reasons[{reason_index}]"
                    ),
                )
                rule_id = reason_record["rule_id"]
                reason = reason_record["reason"]
                if rule_id not in rules or rule_id in seen_non_match_rules:
                    raise AssertionError(
                        f"{citation_key}.{surface}: invalid non-match rule {rule_id!r}"
                    )
                seen_non_match_rules.add(rule_id)
                if rule_id in actual_rule_ids or text is None:
                    raise AssertionError(
                        f"{citation_key}.{surface}: non-match rule is not absent"
                    )
                one_segment = [screening.Segment("SEG-000001", context, 0, len(text))]
                if not _non_match_reason_holds(
                    reason,
                    rules[rule_id],
                    text,
                    one_segment,
                ):
                    raise AssertionError(
                        f"{citation_key}.{surface}: non-match reason did not replay"
                    )
                replayed_reasons.add(reason)
    return replayed_reasons


def _replay_seed_expectations(expectations: dict) -> None:
    expectations = _expect_exact_keys(
        expectations,
        required={
            "schema_version",
            "snapshot_id",
            "snapshot_sha256",
            "label_scope",
            "empirical_accuracy_claimed",
            "contextual_false_positive_labels_provided",
            "contextual_false_negative_labels_provided",
            "inputs",
        },
        label="seed expectations",
    )
    if expectations["schema_version"] != "tortured-phrase-seed-expectations/1.0":
        raise AssertionError("seed expectations schema_version drifted")
    bundle = _bundle()
    if (
        expectations["snapshot_id"] != bundle.snapshot["snapshot_id"]
        or expectations["snapshot_id"] != bundle.manifest["snapshot_id"]
        or expectations["snapshot_sha256"] != bundle.snapshot_sha256
    ):
        raise AssertionError("seed expectations snapshot identity drifted")
    if expectations["label_scope"] != "mechanical_matcher_conformance_only":
        raise AssertionError("seed expectations label scope drifted")
    for flag in (
        "empirical_accuracy_claimed",
        "contextual_false_positive_labels_provided",
        "contextual_false_negative_labels_provided",
    ):
        if expectations[flag] is not False:
            raise AssertionError(f"seed expectations {flag} must remain false")

    inputs = expectations["inputs"]
    if not isinstance(inputs, list):
        raise AssertionError("seed expectations inputs must be an array")
    paths = [item.get("path") if isinstance(item, dict) else None for item in inputs]
    required_paths = {"own_draft.md", "own_draft.tex", "corpus_input.yaml"}
    if (
        any(not isinstance(path, str) for path in paths)
        or len(paths) != len(set(paths))
        or set(paths) != required_paths
    ):
        raise AssertionError("seed expectations input inventory drifted")

    rules = _compiled_rules()
    draft_coverage: set[str] = set()
    corpus_non_match_reasons: set[str] = set()
    for expectation in inputs:
        if expectation["path"] == "corpus_input.yaml":
            corpus_non_match_reasons |= _replay_corpus_expectation(expectation, rules)
        else:
            draft_coverage |= _replay_draft_expectation(expectation, rules)
    required_normalization = {
        "nfkc_casefold",
        "same_line_dash_separator",
        "soft_hyphen_join",
        "line_break_hyphen_join",
    }
    if not required_normalization.issubset(draft_coverage):
        raise AssertionError("seed expectations normalization coverage drifted")
    if "nonmatch:token_boundary" not in draft_coverage:
        raise AssertionError("seed expectations draft token-boundary negative is missing")
    if corpus_non_match_reasons != {
        "token_boundary",
        "exclude_if_in_same_segment",
    }:
        raise AssertionError("seed expectations corpus non-match coverage drifted")


def _strict_dump(path: Path, value: dict) -> None:
    path.write_text(
        json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n",
        encoding="utf-8",
    )


def _snapshot_pair(tmp_path: Path) -> tuple[Path, Path, dict, dict]:
    snapshot = json.loads((FIXTURES / "snapshot.json").read_text(encoding="utf-8"))
    manifest = json.loads(
        (FIXTURES / "snapshot_manifest.json").read_text(encoding="utf-8")
    )
    snapshot_path = tmp_path / "snapshot.json"
    manifest_path = tmp_path / "manifest.json"
    _strict_dump(snapshot_path, snapshot)
    manifest["snapshot_sha256"] = hashlib.sha256(snapshot_path.read_bytes()).hexdigest()
    _strict_dump(manifest_path, manifest)
    return snapshot_path, manifest_path, snapshot, manifest


def _rewrite_pair(
    snapshot_path: Path,
    manifest_path: Path,
    snapshot: dict,
    manifest: dict,
) -> None:
    _strict_dump(snapshot_path, snapshot)
    manifest["snapshot_sha256"] = hashlib.sha256(snapshot_path.read_bytes()).hexdigest()
    manifest["rule_count"] = len(snapshot.get("rules", []))
    _strict_dump(manifest_path, manifest)


def test_snapshot_and_manifest_exact_hash_bind() -> None:
    bundle = _bundle()
    assert bundle.snapshot_sha256 == "962879909bfdd338047dc4569ff42188c4200fcd56a0a459b0e0f9169f2446c4"
    assert len(bundle.rules) == 17
    assert bundle.manifest["unsupported_rule_count"] == 0
    assert bundle.manifest["rights"]["basis"] == "synthetic_fixture"


def test_seed_expectations_are_fully_replayed_as_the_mechanical_oracle() -> None:
    _replay_seed_expectations(_seed_expectations())


def _expectation_input(expectations: dict, path: str) -> dict:
    return next(item for item in expectations["inputs"] if item["path"] == path)


def _corpus_surface(expectations: dict, citation_key: str, surface: str) -> dict:
    corpus = _expectation_input(expectations, "corpus_input.yaml")
    record = next(
        item for item in corpus["records"] if item["citation_key"] == citation_key
    )
    return record["surfaces"][surface]


def _mutate_seed_expectations(expectations: dict, mutation: str) -> None:
    markdown = _expectation_input(expectations, "own_draft.md")
    if mutation == "wrong_count":
        markdown["expected_counts"]["rule_match_count"] += 1
    elif mutation == "wrong_rule":
        markdown["expected_matches"][0]["rule_id"] = "syn_corpus_abstract"
    elif mutation == "wrong_context":
        markdown["expected_matches"][0]["context"] = "quote"
    elif mutation == "wrong_alternative":
        expected = next(
            item
            for item in markdown["expected_matches"]
            if "matched_alternative_index" in item
        )
        expected["matched_alternative_index"] += 1
    elif mutation == "wrong_overlap":
        expected = next(
            item for item in markdown["expected_matches"] if "overlap_group" in item
        )
        expected["overlap_group"] += "-mutated"
    elif mutation == "wrong_normalization":
        expected = next(
            item
            for item in markdown["expected_matches"]
            if item.get("normalization_case") == "nfkc_casefold"
        )
        expected["normalization_case"] = "same_line_dash_separator"
    elif mutation == "wrong_suppression":
        markdown["expected_suppressions"][0]["count"] += 1
    elif mutation == "wrong_nonmatch":
        markdown["expected_non_matches"][0]["reason"] = "exclude_if_in_same_segment"
    elif mutation == "wrong_corpus_status":
        _corpus_surface(expectations, "fixture_complete_2026", "title")[
            "check_status"
        ] = "not_checked"
    elif mutation == "wrong_corpus_reason":
        _corpus_surface(expectations, "fixture_missing_2026", "abstract")[
            "reason"
        ] = "ABSTRACT_EMPTY"
    elif mutation == "wrong_corpus_rule_id":
        _corpus_surface(expectations, "fixture_complete_2026", "title")[
            "expected_rule_ids"
        ] = ["syn_corpus_abstract"]
    elif mutation == "wrong_corpus_nonmatch":
        _corpus_surface(expectations, "fixture_negative_2026", "title")[
            "non_match_reasons"
        ][0]["rule_id"] = "syn_literal_author"
    elif mutation == "wrong_corpus_nonmatch_reason":
        _corpus_surface(expectations, "fixture_negative_2026", "title")[
            "non_match_reasons"
        ][0]["reason"] = "exclude_if_in_same_segment"
    elif mutation == "wrong_snapshot_identity":
        expectations["snapshot_sha256"] = "0" * 64
    elif mutation == "wrong_claim_flag":
        expectations["empirical_accuracy_claimed"] = True
    elif mutation == "unknown_root_key":
        expectations["unexpected"] = True
    elif mutation == "missing_root_key":
        expectations.pop("schema_version")
    elif mutation == "unknown_input":
        expectations["inputs"].append({"path": "unknown.txt"})
    elif mutation == "missing_input":
        expectations["inputs"].pop()
    elif mutation == "duplicate_input":
        expectations["inputs"].append(copy.deepcopy(markdown))
    else:  # pragma: no cover - test parameter list is closed below
        raise AssertionError(f"unknown test mutation {mutation!r}")


@pytest.mark.parametrize(
    "mutation",
    [
        "wrong_count",
        "wrong_rule",
        "wrong_context",
        "wrong_alternative",
        "wrong_overlap",
        "wrong_normalization",
        "wrong_suppression",
        "wrong_nonmatch",
        "wrong_corpus_status",
        "wrong_corpus_reason",
        "wrong_corpus_rule_id",
        "wrong_corpus_nonmatch",
        "wrong_corpus_nonmatch_reason",
        "wrong_snapshot_identity",
        "wrong_claim_flag",
        "unknown_root_key",
        "missing_root_key",
        "unknown_input",
        "missing_input",
        "duplicate_input",
    ],
)
def test_seed_expectation_mutations_fail_closed(mutation: str) -> None:
    expectations = copy.deepcopy(_seed_expectations())
    _mutate_seed_expectations(expectations, mutation)
    with pytest.raises(AssertionError):
        _replay_seed_expectations(expectations)


def test_context_detection_is_never_suppressed() -> None:
    report = _report()
    assert report["check_status"] == "checked"
    assert report["finding"] == "detected"
    assert report["counts"]["unknown_segments"] == 0
    by_rule: dict[str, list[dict]] = {}
    for match in report["matches"]:
        by_rule.setdefault(match["pattern_id"], []).append(match)
    assert by_rule["syn_context_quote"][0]["context"] == "quote"
    assert {item["context"] for item in by_rule["syn_context_code"]} == {
        "code_or_verbatim"
    }
    assert by_rule["syn_context_reference"][0]["context"] == "reference_entry"
    assert all(
        item["disposition"] == "preserve_verbatim_review_context"
        for rule_id in ("syn_context_quote", "syn_context_code", "syn_context_reference")
        for item in by_rule[rule_id]
    )


def test_exclude_if_is_segment_scoped() -> None:
    matches = [
        item for item in _report()["matches"] if item["pattern_id"] == "syn_exclude_segment"
    ]
    assert len(matches) == 1
    assert matches[0]["context"] == "quote"


@pytest.mark.parametrize(
    ("text", "artifact_format"),
    [
        ("moonlit pickle\n\nrecipe glossary", "markdown"),
        (
            "# References\nmoonlit pickle\nrecipe glossary\n",
            "markdown",
        ),
        (
            "\\begin{thebibliography}{9}\n"
            "\\bibitem{a} moonlit pickle\n"
            "\\bibitem{b} recipe glossary\n"
            "\\end{thebibliography}\n",
            "latex",
        ),
    ],
)
def test_exclude_if_never_crosses_paragraph_or_reference_entry(
    text: str, artifact_format: str
) -> None:
    rule = _compiled_rules()["syn_exclude_segment"]
    segments = screening.segment_document(text, artifact_format)
    retained = [
        witness
        for segment in segments
        for witness in screening.evaluate_rule(
            rule, screening.tokenize(text[segment.start : segment.end])
        )
    ]
    assert len(retained) == 1


def test_overlaps_preserve_rule_hits_and_cluster_unique_instances() -> None:
    matches = [
        item
        for item in _report()["matches"]
        if item["pattern_id"] in {"syn_overlap_long", "syn_overlap_short"}
    ]
    assert len(matches) == 2
    assert screening._unique_instance_count(matches) == 1


@pytest.mark.parametrize(
    "rule_id",
    ["syn_nfkc_casefold", "syn_dash_same_line", "syn_soft_hyphen", "syn_hyphen_line_break"],
)
def test_frozen_normalization_cases_match(rule_id: str) -> None:
    assert any(item["pattern_id"] == rule_id for item in _report()["matches"])


@pytest.mark.parametrize(
    ("raw", "expected", "expected_start"),
    [
        ("a-\nb", ["ab"], 0),
        ("silver- \nleaf", ["silver", "leaf"], 0),
        ("silver—\nleaf", ["silver", "leaf"], 0),
        ("1-\na", ["1", "a"], 0),
        ("a-\n2", ["a", "2"], 0),
        ("a1-\nb", ["a1", "b"], 0),
        ("a\u0301-\nb", ["á", "b"], 0),
        ("\u0301alpha", ["alpha"], 1),
    ],
)
def test_only_exact_ascii_immediate_line_hyphen_joins_and_marks_cannot_start(
    raw: str, expected: list[str], expected_start: int
) -> None:
    tokens = screening.tokenize(raw)
    assert [token.normalized for token in tokens] == expected
    assert tokens[0].start == expected_start


def test_token_boundary_prevents_substring_match() -> None:
    assert all(item["pattern_id"] != "syn_boundary_orb" for item in _report()["matches"])


def test_repeated_literal_hits_fail_closed_at_the_witness_cap() -> None:
    tokens = screening.tokenize(" ".join(["orb"] * (screening.MAX_NODE_WITNESSES + 1)))
    with pytest.raises(screening.MatchLimitError, match="literal produced more"):
        screening.evaluate_expression({"op": "literal", "value": "orb"}, tokens)


def test_witness_reducer_deduplicates_only_exact_spans() -> None:
    inner = screening.Witness(2, 3, 2, 3)
    same = screening.Witness(2, 3, 2, 3)
    outer = screening.Witness(1, 4, 1, 4)
    separate = screening.Witness(5, 6, 5, 6)
    assert screening._minimal_witnesses([outer, inner, same, separate]) == [
        outer,
        inner,
        separate,
    ]


def test_any_and_all_preserve_distinct_nested_witnesses() -> None:
    tokens = screening.tokenize("amber reed reed")
    any_values = screening.evaluate_expression(
        {
            "op": "any",
            "alternatives": [
                {"op": "literal", "value": "amber"},
                {"op": "literal", "value": "amber reed"},
            ],
        },
        tokens,
    )
    assert [(item.token_start, item.token_end) for item in any_values] == [
        (0, 1),
        (0, 2),
    ]
    all_values = screening.evaluate_expression(
        {
            "op": "all",
            "terms": [
                {"op": "literal", "value": "amber"},
                {"op": "literal", "value": "reed"},
            ],
            "max_span_tokens": 3,
        },
        tokens,
    )
    assert [(item.token_start, item.token_end) for item in all_values] == [
        (0, 2),
        (0, 3),
    ]


def test_full_scan_counts_nested_same_rule_witnesses_as_one_overlap_instance() -> None:
    expression = {
        "op": "any",
        "alternatives": [
            {"op": "literal", "value": "amber"},
            {"op": "literal", "value": "amber reed"},
        ],
    }
    base = _bundle()
    rule = screening.CompiledRule(
        rule_id="nested_union",
        expression=expression,
        exclude_if=(),
        rule_sha256=screening._sha256_text(screening._canonical_json(expression)),
        semantic_key=screening._canonical_json(expression),
    )
    bundle = screening.SnapshotBundle(
        snapshot=base.snapshot,
        manifest=base.manifest,
        snapshot_sha256=base.snapshot_sha256,
        manifest_sha256=base.manifest_sha256,
        rules=(rule,),
        unicode_data_version=base.unicode_data_version,
    )
    text = "amber reed"
    matches, counts = screening.scan_segments(
        text,
        [screening.Segment("SEG-000001", "author_prose", 0, len(text))],
        bundle,
        artifact_sha256=hashlib.sha256(text.encode()).hexdigest(),
        surface="own_draft",
    )
    assert len(matches) == 2
    assert counts["rule_match_count"] == 2
    assert counts["matched_rule_count"] == 1
    assert counts["unique_instance_count"] == 1


def test_utf8_and_codepoint_spans_replay_multibyte_text() -> None:
    report = screening.build_own_draft_report(
        "前文 luminous turnip 後文",
        artifact_id="unicode.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    match = next(item for item in report["matches"] if item["pattern_id"] == "syn_literal_author")
    span = match["source_span"]
    text = "前文 luminous turnip 後文"
    assert text[span["codepoint_start"] : span["codepoint_end"]] == match["matched_text"]
    raw = text.encode("utf-8")
    assert raw[span["utf8_start"] : span["utf8_end"]].decode() == match["matched_text"]


@pytest.mark.parametrize("name", ["own_draft.md", "own_draft.tex"])
def test_segment_partition_covers_source_exactly(name: str) -> None:
    text = _draft(name)
    segments = screening.segment_document(text, "latex" if name.endswith(".tex") else "markdown")
    assert segments[0].start == 0
    assert segments[-1].end == len(text)
    assert all(left.end == right.start for left, right in zip(segments, segments[1:]))


def test_reference_heading_inside_fence_does_not_reclassify_following_prose() -> None:
    text = "```text\n# References\n```\nFollowing luminous turnip."
    segments = screening.segment_document(text, "markdown")
    following = next(item for item in segments if item.start <= text.index("Following") < item.end)
    assert following.kind == "author_prose"


def test_reference_heading_inside_html_comment_does_not_reclassify_prose() -> None:
    text = "<!--\n# References\n-->\nordinary luminous turnip\n"
    segments = screening.segment_document(text, "markdown")
    following = next(
        item for item in segments if item.start <= text.index("ordinary") < item.end
    )
    assert following.kind == "author_prose"
    report = screening.build_own_draft_report(
        text,
        artifact_id="comment-heading.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    prose_match = next(
        item for item in report["matches"] if item["matched_text"] == "luminous turnip"
    )
    assert prose_match["context"] == "author_prose"


@pytest.mark.parametrize("marker", ["```python", "~~~text"])
def test_fence_opener_inside_html_comment_cannot_leak_unknown_context(
    marker: str,
) -> None:
    text = f"<!--\n{marker}\n-->\nordinary luminous turnip\n"
    segments = screening.segment_document(text, "markdown")
    following = next(
        item for item in segments if item.start <= text.index("ordinary") < item.end
    )
    assert following.kind == "author_prose"
    assert all(item.kind != "unknown" for item in segments)


def test_latex_environment_opener_inside_comment_cannot_leak_context() -> None:
    text = (
        "% \\begin{thebibliography}{9}\n"
        "ordinary luminous turnip\n"
        "\\end{thebibliography}\n"
    )
    segments = screening.segment_document(text, "latex")
    following = next(
        item for item in segments if item.start <= text.index("ordinary") < item.end
    )
    assert following.kind == "author_prose"
    report = screening.build_own_draft_report(
        text,
        artifact_id="comment-environment.tex",
        artifact_format="latex",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    prose_match = next(
        item for item in report["matches"] if item["matched_text"] == "luminous turnip"
    )
    assert prose_match["context"] == "author_prose"


@pytest.mark.parametrize(
    ("environment", "expected_kind"),
    [
        ("thebibliography", "reference_entry"),
        ("quote", "quote"),
        ("verbatim", "code_or_verbatim"),
    ],
)
def test_latex_environment_escape_parity(
    environment: str, expected_kind: str
) -> None:
    even = (
        "\\" * 2
        + f"begin{{{environment}}}\nordinary\n"
        + "\\" * 2
        + f"end{{{environment}}}\n"
    )
    assert all(
        item.kind == "author_prose"
        for item in screening.segment_document(even, "latex")
    )
    odd = (
        "\\" * 3
        + f"begin{{{environment}}}\nordinary\n"
        + "\\" * 3
        + f"end{{{environment}}}\n"
    )
    assert any(
        item.kind == expected_kind
        for item in screening.segment_document(odd, "latex")
    )


def test_latex_verb_escape_parity_and_opaque_opener_precedence() -> None:
    even = r"\\verb|ordinary luminous turnip|"
    assert all(
        item.kind == "author_prose"
        for item in screening.segment_document(even, "latex")
    )
    active = r"\verb|\begin{verbatim}| ordinary luminous turnip"
    segments = screening.segment_document(active, "latex")
    following = next(
        item for item in segments if item.start <= active.index("ordinary") < item.end
    )
    assert following.kind == "author_prose"
    assert all(item.kind != "unknown" for item in segments)


def test_source_order_opaque_lexer_does_not_let_inner_opener_consume_later_close() -> None:
    text = (
        r"\verb|\begin{verbatim}| "
        r"\begin{verbatim} recipe glossary \end{verbatim} moonlit pickle"
    )
    segments = screening.segment_document(text, "latex")
    real_environment = text.index(r"\begin{verbatim}", len(r"\verb|"))
    later_prose = text.index("moonlit pickle")
    assert next(
        item for item in segments if item.start <= real_environment < item.end
    ).kind == "code_or_verbatim"
    assert next(
        item for item in segments if item.start <= later_prose < item.end
    ).kind == "author_prose"
    report = screening.build_own_draft_report(
        text,
        artifact_id="source-order.tex",
        artifact_format="latex",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert any(
        item["pattern_id"] == "syn_exclude_segment"
        and item["matched_text"] == "moonlit pickle"
        for item in report["matches"]
    )


def test_source_order_markdown_comment_does_not_consume_later_inline_code() -> None:
    text = "<!-- ` --> `luminous turnip`"
    segments = screening.segment_document(text, "markdown")
    later = text.index("`luminous")
    assert next(item for item in segments if item.start <= later < item.end).kind == (
        "code_or_verbatim"
    )
    assert all(item.kind != "unknown" for item in segments)


def test_blockquote_marker_inside_comment_cannot_capture_later_prose() -> None:
    text = '<!--\n> --> "recipe glossary" moonlit pickle\n'
    segments = screening.segment_document(text, "markdown")
    target = text.index("moonlit pickle")
    assert next(item for item in segments if item.start <= target < item.end).kind == (
        "author_prose"
    )
    report = screening.build_own_draft_report(
        text,
        artifact_id="comment-blockquote.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert any(
        item["pattern_id"] == "syn_exclude_segment"
        and item["matched_text"] == "moonlit pickle"
        for item in report["matches"]
    )


def test_context_openers_inside_opaque_bytes_do_not_consume_later_context() -> None:
    text = '`"` "recipe glossary" moonlit pickle '
    text += '`[` [Visible title](https://doi.org/10.1/example)'
    segments = screening.segment_document(text, "markdown")
    glossary = text.index('"recipe glossary"')
    title = text.index("Visible title")
    assert next(item for item in segments if item.start <= glossary < item.end).kind == (
        "quote"
    )
    assert next(item for item in segments if item.start <= title < item.end).kind == (
        "cited_title"
    )
    report = screening.build_own_draft_report(
        text,
        artifact_id="opaque-context.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert any(
        item["pattern_id"] == "syn_exclude_segment"
        and item["matched_text"] == "moonlit pickle"
        for item in report["matches"]
    )


@pytest.mark.parametrize(
    "text",
    [
        r"\verbose ordinary luminous turnip",
        r"\verbatim ordinary luminous turnip",
    ],
)
def test_latex_verb_control_word_prefixes_remain_prose(text: str) -> None:
    assert all(
        item.kind == "author_prose"
        for item in screening.segment_document(text, "latex")
    )


def test_latex_starred_verb_and_nested_quote_are_recognized() -> None:
    starred = r"\verb*|ordinary luminous turnip|"
    assert any(
        item.kind == "code_or_verbatim"
        and starred[item.start : item.end] == starred
        for item in screening.segment_document(starred, "latex")
    )
    nested = (
        r"\begin{quote} outer \begin{quote} inner \end{quote} "
        r"tail \end{quote}"
    )
    tail = nested.index("tail")
    assert next(
        item
        for item in screening.segment_document(nested, "latex")
        if item.start <= tail < item.end
    ).kind == "quote"


@pytest.mark.parametrize("text", [r"\verb ", "\\verb\n", r"\verb* "])
def test_malformed_bare_latex_verb_is_unknown(text: str) -> None:
    assert any(
        item.kind == "unknown"
        for item in screening.segment_document(text, "latex")
    )


def test_starred_latex_verb_cannot_backtrack_into_unstarred_delimiter() -> None:
    text = r"\verb* foo * ordinary luminous turnip"
    segments = screening.segment_document(text, "latex")
    assert len(segments) == 1
    assert segments[0].kind == "unknown"


def test_latex_accent_macro_quotes_remain_author_prose() -> None:
    text = r'\"o ordinary luminous turnip \"u'
    assert all(
        item.kind == "author_prose"
        for item in screening.segment_document(text, "latex")
    )


@pytest.mark.parametrize(
    "target",
    [
        "HTTPS://DOI.ORG/10.1/example",
        "HTTP://DX.DOI.ORG/10.1/example",
        "DOI:10.1/example",
    ],
)
def test_doi_title_prefix_is_ascii_case_insensitive(target: str) -> None:
    text = f"[Cited Turnip]({target})"
    title = text.index("Cited Turnip")
    assert next(
        item
        for item in screening.segment_document(text, "markdown")
        if item.start <= title < item.end
    ).kind == "cited_title"


def test_opaque_opener_cap_precedes_unclosed_verb_pairing(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_PARSE_INTERVALS", 3)
    with pytest.raises(screening.MatchLimitError, match="opaque parse candidates"):
        screening.segment_document(r"\verb!" * 4, "latex")


def test_unclosed_context_scanners_advance_monotonically() -> None:
    text = "[" * 20_000 + "\n" + "“" * 10_000
    segments = screening.segment_document(text, "markdown")
    assert len(segments) == 1
    assert segments[0].kind == "author_prose"


def test_escaped_latex_environment_closer_does_not_close_early() -> None:
    text = (
        "\\begin{thebibliography}{9}\n"
        "\\\\end{thebibliography}\n"
        "ordinary luminous turnip\n"
        "\\end{thebibliography}\n"
    )
    following = next(
        item
        for item in screening.segment_document(text, "latex")
        if item.start <= text.index("ordinary") < item.end
    )
    assert following.kind == "reference_entry"


@pytest.mark.parametrize(
    "text",
    [
        r"\(\begin{quote}\) ordinary luminous turnip",
        r"$\begin{thebibliography}$ ordinary luminous turnip",
        r"\[\begin{verbatim}\] ordinary luminous turnip",
    ],
)
def test_latex_environment_openers_inside_math_are_opaque(text: str) -> None:
    segments = screening.segment_document(text, "latex")
    following = next(
        item for item in segments if item.start <= text.index("ordinary") < item.end
    )
    assert following.kind == "author_prose"
    assert all(item.kind != "unknown" for item in segments)


@pytest.mark.parametrize("artifact_format", ["markdown", "latex"])
def test_odd_backslash_escaped_dollar_is_literal_prose(
    artifact_format: str,
) -> None:
    text = r"Cost is \$5."
    segments = screening.segment_document(text, artifact_format)
    assert all(segment.kind == "author_prose" for segment in segments)


def test_markdown_backtick_escape_parity_is_respected() -> None:
    escaped = r"Literal \` tick."
    assert all(
        segment.kind == "author_prose"
        for segment in screening.segment_document(escaped, "markdown")
    )
    active = r"Literal \\`code` tick."
    assert any(
        segment.kind == "code_or_verbatim"
        for segment in screening.segment_document(active, "markdown")
    )


def test_latex_percent_escape_parity_is_respected() -> None:
    escaped = r"Literal \% text."
    assert all(
        segment.kind == "author_prose"
        for segment in screening.segment_document(escaped, "latex")
    )
    active = r"Literal \\% comment"
    assert any(
        segment.kind == "code_or_verbatim"
        for segment in screening.segment_document(active, "latex")
    )


def test_unclosed_construct_is_unknown_and_degrades_not_clean() -> None:
    report = screening.build_own_draft_report(
        "Ordinary prose `luminous turnip",
        artifact_id="broken.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert report["check_status"] == "degraded"
    assert report["finding"] == "unresolved"
    assert report["reason_code"] == "DOCUMENT_PARSE_DEGRADED"
    assert report["counts"]["unknown_segments"] > 0
    assert report["matches"]
    assert report["matches"][0]["disposition"] == "review_unknown_no_automatic_rewrite"


def test_segment_resource_cap_degrades_without_partial_matches(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_SEGMENTS", 1)
    report = screening.build_own_draft_report(
        "prose `code` prose",
        artifact_id="many-segments.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert report["check_status"] == "degraded"
    assert report["reason_code"] == "MATCH_RESOURCE_LIMIT"
    assert report["matches"] == []
    assert report["counts"]["rules_evaluated"] == 0


@pytest.mark.parametrize(
    "text",
    [
        "a\n\nb\n\nc\n\n",
        "# References\none\ntwo\nthree\n",
    ],
)
def test_partition_boundaries_fail_while_collecting(
    monkeypatch: pytest.MonkeyPatch, text: str
) -> None:
    monkeypatch.setattr(screening, "MAX_SEGMENTS", 2)
    with pytest.raises(screening.MatchLimitError, match="document partition exceeds 2"):
        screening.segment_document(text, "markdown")


def test_over_token_input_fails_before_utf8_endpoint_projection(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    bundle = _bundle()
    monkeypatch.setattr(screening, "MAX_TOKENS", 1)

    def unexpected_offsets(_text, _indices):
        raise AssertionError("UTF-8 endpoint projection must follow token admission")

    monkeypatch.setattr(screening, "_selected_byte_offsets", unexpected_offsets)
    with pytest.raises(screening.MatchLimitError, match="token count exceeds 1"):
        screening.scan_segments(
            "alpha beta",
            [screening.Segment("SEG-000001", "author_prose", 0, 10)],
            bundle,
            artifact_sha256=hashlib.sha256(b"alpha beta").hexdigest(),
            surface="own_draft",
        )


def test_raw_token_expansion_is_bounded_before_normalization(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_RAW_TOKEN_CODEPOINTS", 2)

    def unexpected_normalization(_value: str):
        raise AssertionError("overlong raw token must fail before NFKC expansion")

    monkeypatch.setattr(screening, "_normalized_token_parts", unexpected_normalization)
    with pytest.raises(screening.MatchLimitError, match="raw token exceeds 2"):
        screening.tokenize("\ufdfa" * 3)


def test_raw_token_cap_accepts_n_and_rejects_n_plus_one(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_RAW_TOKEN_CODEPOINTS", 2)
    assert [item.normalized for item in screening.tokenize("ab")] == ["ab"]
    with pytest.raises(screening.MatchLimitError, match="raw token exceeds 2"):
        screening.tokenize("abc")


def test_parser_work_budget_accepts_n_and_rejects_n_plus_one(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_PARSE_WORK_UNITS", 2)
    budget = screening.ParseWorkBudget()
    budget.spend()
    budget.spend()
    with pytest.raises(screening.MatchLimitError, match="parser work exceeds 2"):
        budget.spend()


def test_escaped_and_doi_closer_candidates_spend_parser_budget(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_PARSE_WORK_UNITS", 2)
    accepted = screening.ParseWorkBudget()
    assert screening._find_unescaped(r"\$$", "$", 0, budget=accepted) == 2
    exhausted = screening.ParseWorkBudget()
    with pytest.raises(screening.MatchLimitError, match="parser work exceeds 2"):
        screening._find_unescaped(r"\$\$$", "$", 0, budget=exhausted)
    doi_budget = screening.ParseWorkBudget()
    with pytest.raises(screening.MatchLimitError, match="parser work exceeds 2"):
        screening._doi_title_intervals(
            "[title](doi:10.1/example)",
            excluded=(),
            budget=doi_budget,
        )


@pytest.mark.parametrize(
    ("text", "artifact_format"),
    [
        ("<!--\n> one\n> two\n> three\n-->", "markdown"),
        (r"\end{quote}\end{quote}\end{quote}\end{quote}", "latex"),
    ],
)
def test_excluded_and_unmatched_context_candidates_spend_parser_budget(
    monkeypatch: pytest.MonkeyPatch,
    text: str,
    artifact_format: str,
) -> None:
    monkeypatch.setattr(screening, "MAX_PARSE_WORK_UNITS", 3)
    with pytest.raises(screening.MatchLimitError, match="parser work exceeds 3"):
        screening.segment_document(text, artifact_format)


def test_selected_utf8_offsets_are_exact_and_endpoint_bounded() -> None:
    text = "A台灣B"
    assert screening._selected_byte_offsets(text, {0, 1, 3, 4}) == {
        0: 0,
        1: 1,
        3: 7,
        4: 8,
    }


def test_delimiter_parser_enforces_interval_cap_before_return(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_PARSE_INTERVALS", 2)
    with pytest.raises(screening.MatchLimitError, match="parse interval count exceeds 2"):
        screening._paired_delimiter_intervals(
            "$one$ $two$ $three$", "$", "$", "code_or_verbatim"
        )


def test_rule_by_segment_work_is_globally_bounded(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_RULE_SEGMENT_EVALUATIONS", 1)
    with pytest.raises(
        screening.MatchLimitError, match="rule-by-segment evaluations exceed 1"
    ):
        screening.scan_segments(
            "luminous turnip",
            [screening.Segment("SEG-000001", "author_prose", 0, 16)],
            _bundle(),
            artifact_sha256=hashlib.sha256(b"luminous turnip").hexdigest(),
            surface="own_draft",
        )


def test_literal_and_composition_work_budget_is_shared_across_corpus(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_MATCH_WORK_UNITS", 300)
    output = _enriched()
    first, second = output["literature_corpus"][:2]
    assert all(
        signal["check_status"] == "checked"
        for signal in first["bibliographic_integrity_signals"]
    )
    second_title = next(
        signal
        for signal in second["bibliographic_integrity_signals"]
        if signal["tortured_phrase_context"]["surface"] == "cited_title"
    )
    assert second_title["check_status"] == "degraded"
    assert (
        second_title["tortured_phrase_context"]["reason_code"]
        == "MATCH_RESOURCE_LIMIT"
    )
    assert second_title["tortured_phrase_context"]["matches"] == []


def test_report_digest_and_full_replay() -> None:
    report = _report()
    screening.validate_own_draft_report(report, _draft("own_draft.md"), state=_state())
    report["counts"]["rule_match_count"] += 1
    with pytest.raises(screening.ScreeningError, match="report_sha256"):
        screening.validate_own_draft_report(report, _draft("own_draft.md"), state=_state())


def test_rehashed_report_still_fails_source_replay() -> None:
    report = _report()
    report["matches"][0]["matched_text"] = "forged"
    report["matches"][0]["matched_text_sha256"] = screening._sha256_text("forged")
    report["report_sha256"] = screening._report_digest(report)
    with pytest.raises(screening.ScreeningError, match="replay"):
        screening.validate_own_draft_report(report, _draft("own_draft.md"), state=_state())


def test_oversized_full_report_collapses_to_a_self_readable_degraded_artifact(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    text = " ".join(["luminous turnip"] * 100)
    monkeypatch.setattr(screening, "MAX_ADVISORY_BYTES", 5000)
    report = screening.build_own_draft_report(
        text,
        artifact_id="bounded.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert report["check_status"] == "degraded"
    assert report["reason_code"] == "MATCH_RESOURCE_LIMIT"
    assert report["matches"] == []
    assert len(screening._pretty_json_bytes(report)) <= screening.MAX_ADVISORY_BYTES
    path = tmp_path / "report.json"
    screening._atomic_write_json(
        path, report, maximum=screening.MAX_ADVISORY_BYTES
    )
    assert screening._load_report(path) == report
    screening.validate_own_draft_report(report, text, state=_state())


def test_bounded_reader_rejects_before_consuming_beyond_limit(tmp_path: Path) -> None:
    path = tmp_path / "oversized.bin"
    path.write_bytes(b"x" * 9)
    with pytest.raises(screening.MatchLimitError, match="exceeds 8 bytes"):
        screening._read_bounded_bytes(path, maximum=8)


def test_no_snapshot_is_explicit_not_checked() -> None:
    state = screening.snapshot_state(None, None)
    report = screening.build_own_draft_report(
        "luminous turnip",
        artifact_id="draft.md",
        artifact_format="markdown",
        state=state,
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert report["check_status"] == "not_checked"
    assert report["finding"] == "unresolved"
    assert report["reason_code"] == "SNAPSHOT_NOT_PROVIDED"
    assert report["matches"] == []


@pytest.mark.parametrize(
    "state",
    [
        screening.snapshot_state(None, None),
        screening.snapshot_state(FIXTURES / "snapshot.json", None),
    ],
)
def test_empty_draft_preserves_missing_or_degraded_snapshot_authority(
    state: screening.SnapshotState,
) -> None:
    report = screening.build_own_draft_report(
        "",
        artifact_id="empty.md",
        artifact_format="markdown",
        state=state,
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert report["check_status"] == (
        "not_checked" if state.status == "not_checked" else "degraded"
    )
    assert report["reason_code"] == state.reason_code
    assert report["finding"] == "unresolved"
    screening.validate_own_draft_report(report, "", state=state)


def test_empty_draft_is_degraded_never_a_zero_match() -> None:
    report = screening.build_own_draft_report(
        " \t\n",
        artifact_id="empty.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert report["check_status"] == "degraded"
    assert report["finding"] == "unresolved"
    assert report["reason_code"] == "DOCUMENT_EMPTY"
    assert report["matches"] == []
    assert report["counts"]["rules_evaluated"] == 0


def test_snapshot_byte_tamper_fails_hash_before_content_access() -> None:
    manifest = FIXTURES / "snapshot_manifest.json"
    state = screening.snapshot_state(FIXTURES / "own_draft.md", manifest)
    assert state.status == "degraded"
    assert state.reason_code == "SNAPSHOT_HASH_MISMATCH"


@pytest.mark.parametrize(
    ("raw", "reason"),
    [
        (b"\xef\xbb\xbf{}", "SNAPSHOT_BYTES_INVALID"),
        (b"\xff", "SNAPSHOT_BYTES_INVALID"),
        (b'{"schema_version":"a","schema_version":"b"}', "SNAPSHOT_BYTES_INVALID"),
        (b'{"x":NaN}', "SNAPSHOT_BYTES_INVALID"),
    ],
)
def test_strict_snapshot_loader_rejects_unsafe_bytes(
    tmp_path: Path, raw: bytes, reason: str
) -> None:
    snapshot_path = tmp_path / "bad.json"
    snapshot_path.write_bytes(raw)
    manifest = json.loads(
        (FIXTURES / "snapshot_manifest.json").read_text(encoding="utf-8")
    )
    manifest["snapshot_sha256"] = hashlib.sha256(raw).hexdigest()
    manifest_path = tmp_path / "manifest.json"
    _strict_dump(manifest_path, manifest)
    state = screening.snapshot_state(snapshot_path, manifest_path)
    assert state.status == "degraded"
    assert state.reason_code == reason


def test_draft_reader_rejects_isolated_carriage_return(tmp_path: Path) -> None:
    draft = tmp_path / "draft.md"
    draft.write_bytes(b"alpha\rbeta")
    with pytest.raises(screening.ScreeningError, match="isolated carriage return"):
        screening._read_strict_text(
            draft, maximum=screening.MAX_DOCUMENT_BYTES, label="draft"
        )


def test_direct_builder_allows_crlf_but_rejects_isolated_carriage_return() -> None:
    screening.build_own_draft_report(
        "alpha\r\nbeta",
        artifact_id="draft.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    with pytest.raises(screening.ScreeningError, match="isolated carriage return"):
        screening.build_own_draft_report(
            "alpha\rbeta",
            artifact_id="draft.md",
            artifact_format="markdown",
            state=_state(),
            checked_at=CHECKED_AT,
            recorded_at=RECORDED_AT,
        )


def test_manifest_hash_mismatch_never_checks_remaining_rules(tmp_path: Path) -> None:
    snapshot_path, manifest_path, snapshot, manifest = _snapshot_pair(tmp_path)
    snapshot["rules"][0]["expression"]["value"] = "changed phrase"
    _strict_dump(snapshot_path, snapshot)
    state = screening.snapshot_state(snapshot_path, manifest_path)
    assert state.reason_code == "SNAPSHOT_HASH_MISMATCH"


def test_manifest_snapshot_identity_must_match_hash_bound_snapshot(
    tmp_path: Path,
) -> None:
    snapshot_path, manifest_path, _snapshot, manifest = _snapshot_pair(tmp_path)
    manifest["snapshot_id"] = "forged-snapshot-id"
    _strict_dump(manifest_path, manifest)
    state = screening.snapshot_state(snapshot_path, manifest_path)
    assert state.status == "degraded"
    assert state.reason_code == "SNAPSHOT_HASH_MISMATCH"


@pytest.mark.parametrize(
    "mutation",
    [
        "synthetic_reference",
        "user_without_declaration",
        "permission_without_reference",
        "unresolved_but_permitted",
        "null_source_locator",
    ],
)
def test_manifest_rights_and_source_projection_fail_closed(
    tmp_path: Path, mutation: str
) -> None:
    snapshot_path, manifest_path, _snapshot, manifest = _snapshot_pair(tmp_path)
    if mutation == "synthetic_reference":
        manifest["rights"]["reference"] = "unexpected reference"
    elif mutation == "user_without_declaration":
        manifest["supply_mode"] = "user_supplied"
        manifest["rights"] = {
            "basis": "user_declared_authorized",
            "redistribution_status": "permitted",
            "reference": None,
            "user_declaration": None,
        }
    elif mutation == "permission_without_reference":
        manifest["supply_mode"] = "user_supplied"
        manifest["rights"] = {
            "basis": "written_permission",
            "redistribution_status": "permitted",
            "reference": None,
            "user_declaration": None,
        }
    elif mutation == "unresolved_but_permitted":
        manifest["supply_mode"] = "user_supplied"
        manifest["rights"] = {
            "basis": "unresolved",
            "redistribution_status": "permitted",
            "reference": None,
            "user_declaration": None,
        }
    else:
        manifest["source"]["locator"] = None
    _strict_dump(manifest_path, manifest)
    state = screening.snapshot_state(snapshot_path, manifest_path)
    assert state.status == "degraded"
    assert state.reason_code == "SNAPSHOT_MANIFEST_INVALID"


def test_advisory_schema_mirrors_manifest_rights_conditionals() -> None:
    report = _report()
    validator = Draft202012Validator(
        screening._load_schema(screening.ADVISORY_SCHEMA_PATH),
        format_checker=Draft202012Validator.FORMAT_CHECKER,
    )
    rights = report["input_binding"]["snapshot"]["rights"]
    rights["basis"] = "user_declared_authorized"
    rights["user_declaration"] = None
    assert list(validator.iter_errors(report))


def test_explicit_but_unreadable_snapshot_is_degraded_not_absent(
    tmp_path: Path,
) -> None:
    missing = tmp_path / "missing-snapshot.json"
    state = screening.snapshot_state(missing, FIXTURES / "snapshot_manifest.json")
    assert state.status == "degraded"
    assert state.reason_code == "SNAPSHOT_BYTES_INVALID"
    signal = screening.build_cited_signal(
        _passport()["literature_corpus"][0],
        surface="cited_title",
        state=state,
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert signal["check_status"] == "degraded"
    assert signal["tortured_phrase_context"]["reason_code"] == "SNAPSHOT_BYTES_INVALID"


@pytest.mark.parametrize(
    ("mutation", "expected_reason"),
    [
        (lambda snap, man: snap.update({"grammar_profile": "unknown/9"}), "SNAPSHOT_PROFILE_UNSUPPORTED"),
        (lambda snap, man: snap.update({"rules": []}), "SNAPSHOT_MANIFEST_INVALID"),
        (
            lambda snap, man: snap["rules"][0].update(
                {"expression": {"op": "regex", "value": ".*"}}
            ),
            "SNAPSHOT_RULES_UNSUPPORTED",
        ),
        (
            lambda snap, man: snap["rules"].append(copy.deepcopy(snap["rules"][0])),
            "SNAPSHOT_RULES_UNSUPPORTED",
        ),
        (
            lambda snap, man: man.update({"unsupported_rule_count": 1}),
            "SNAPSHOT_RULES_UNSUPPORTED",
        ),
    ],
)
def test_invalid_or_partial_grammar_is_never_clean(
    tmp_path: Path, mutation, expected_reason: str
) -> None:
    snapshot_path, manifest_path, snapshot, manifest = _snapshot_pair(tmp_path)
    mutation(snapshot, manifest)
    _rewrite_pair(snapshot_path, manifest_path, snapshot, manifest)
    state = screening.snapshot_state(snapshot_path, manifest_path)
    assert state.status == "degraded"
    assert state.reason_code == expected_reason


@pytest.mark.parametrize(
    "injected_value",
    ["grammar_profile", "normalizer_profile", "schema_version"],
)
def test_invalid_rule_text_cannot_inject_profile_failure_reason(
    tmp_path: Path, injected_value: str
) -> None:
    snapshot_path, manifest_path, snapshot, manifest = _snapshot_pair(tmp_path)
    snapshot["rules"][0]["expression"] = {
        "op": "regex",
        "value": injected_value,
    }
    _rewrite_pair(snapshot_path, manifest_path, snapshot, manifest)
    state = screening.snapshot_state(snapshot_path, manifest_path)
    assert state.status == "degraded"
    assert state.reason_code == "SNAPSHOT_RULES_UNSUPPORTED"


def test_semantically_duplicate_rule_is_rejected(tmp_path: Path) -> None:
    snapshot_path, manifest_path, snapshot, manifest = _snapshot_pair(tmp_path)
    duplicate = copy.deepcopy(snapshot["rules"][0])
    duplicate["rule_id"] = "different_id_same_semantics"
    snapshot["rules"].append(duplicate)
    _rewrite_pair(snapshot_path, manifest_path, snapshot, manifest)
    state = screening.snapshot_state(snapshot_path, manifest_path)
    assert state.reason_code == "SNAPSHOT_RULES_UNSUPPORTED"


def test_near_gap_is_intervening_token_count_and_ordered() -> None:
    rule = next(item for item in _bundle().rules if item.rule_id == "syn_near_ordered")
    assert screening.evaluate_rule(rule, screening.tokenize("nebula x cabbage"))
    assert not screening.evaluate_rule(rule, screening.tokenize("nebula x y cabbage"))
    assert not screening.evaluate_rule(rule, screening.tokenize("cabbage x nebula"))


def test_near_never_crosses_context_segments() -> None:
    report = screening.build_own_draft_report(
        "nebula `x` cabbage",
        artifact_id="segments.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert all(item["pattern_id"] != "syn_near_ordered" for item in report["matches"])


def test_explicit_timestamps_only_no_ambient_clock_source() -> None:
    source = (SCRIPTS / "tortured_phrase_screening.py").read_text(encoding="utf-8")
    assert ".now(" not in source
    with pytest.raises(screening.ScreeningError, match="explicit RFC 3339"):
        screening.build_own_draft_report(
            "luminous turnip",
            artifact_id="draft.md",
            artifact_format="markdown",
            state=_state(),
            checked_at="today",
            recorded_at=RECORDED_AT,
        )


def test_recorded_at_cannot_precede_checked_at() -> None:
    with pytest.raises(screening.ScreeningError, match="must not precede"):
        screening.build_own_draft_report(
            "luminous turnip",
            artifact_id="draft.md",
            artifact_format="markdown",
            state=_state(),
            checked_at="2026-08-10T01:00:01Z",
            recorded_at="2026-08-10T01:00:00Z",
        )
    entry = _passport()["literature_corpus"][0]
    with pytest.raises(screening.ScreeningError, match="must not precede"):
        screening.build_cited_signal(
            entry,
            surface="cited_title",
            state=_state(),
            checked_at="2026-08-10T01:00:01Z",
            recorded_at="2026-08-10T01:00:00Z",
        )


def test_submicrosecond_timestamp_order_cannot_be_truncated() -> None:
    checked_at = "2026-08-10T01:00:00.0000009Z"
    recorded_at = "2026-08-10T01:00:00.0000001Z"
    with pytest.raises(screening.ScreeningError, match="explicit RFC 3339"):
        screening.build_own_draft_report(
            "luminous turnip",
            artifact_id="draft.md",
            artifact_format="markdown",
            state=_state(),
            checked_at=checked_at,
            recorded_at=recorded_at,
        )
    with pytest.raises(screening.ScreeningError, match="explicit RFC 3339"):
        screening.build_cited_signal(
            _passport()["literature_corpus"][0],
            surface="cited_title",
            state=_state(),
            checked_at=checked_at,
            recorded_at=recorded_at,
        )


def test_renderer_is_one_page_bounded_and_has_claim_ceiling() -> None:
    report = _report()
    rendered = screening.render_own_draft_report(
        report, _draft("own_draft.md"), state=_state()
    )
    assert screening.SUMMARY_LABEL in rendered
    assert "does not establish papermill, AI, or author origin" in rendered
    assert "not a clean-text certificate" in rendered
    assert "one fixed page capped at 25" in rendered
    assert "--all" not in rendered


def test_renderer_reports_omitted_count_and_machine_replay_key() -> None:
    text = " ".join(["luminous turnip"] * 30)
    report = screening.build_own_draft_report(
        text,
        artifact_id="many-matches.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert len(report["matches"]) > screening.MAX_RENDER_PAGE_SIZE
    rendered = screening.render_own_draft_report(report, text, state=_state())
    omitted = len(report["matches"]) - screening.MAX_RENDER_PAGE_SIZE
    assert f"omitted {omitted}" in rendered
    assert "Complete machine JSON replay key" in rendered
    assert "artifact_id=many-matches.md" in rendered
    assert report["report_sha256"] in rendered


def test_renderer_uses_outcome_specific_zero_and_unresolved_wording() -> None:
    zero = screening.build_own_draft_report(
        "ordinary unmatched prose",
        artifact_id="zero.md",
        artifact_format="markdown",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    rendered_zero = screening.render_own_draft_report(
        zero, "ordinary unmatched prose", state=_state()
    )
    assert screening.SUMMARY_LABEL not in rendered_zero
    assert "No phrase-list match observed on the checked surface" in rendered_zero
    assert "not a clean-text certificate" in rendered_zero

    unresolved_state = screening.snapshot_state(None, None)
    unresolved = screening.build_own_draft_report(
        "ordinary unmatched prose",
        artifact_id="unresolved.md",
        artifact_format="markdown",
        state=unresolved_state,
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    rendered_unresolved = screening.render_own_draft_report(
        unresolved, "ordinary unmatched prose", state=unresolved_state
    )
    assert screening.SUMMARY_LABEL not in rendered_unresolved
    assert "screening is unresolved" in rendered_unresolved


def test_renderer_escapes_markdown_and_html_injection() -> None:
    assert "<img" not in screening._markdown_cell("<img src=x>")
    assert "\\[click\\]" in screening._markdown_cell("[click](https://example.invalid)")


def test_corpus_rows_are_per_surface_and_missing_abstract_is_explicit() -> None:
    output = _enriched()
    by_key = {item["citation_key"]: item for item in output["literature_corpus"]}
    complete = by_key["fixture_complete_2026"]["bibliographic_integrity_signals"]
    assert {item["tortured_phrase_context"]["surface"] for item in complete} == {
        "cited_title",
        "cited_abstract",
    }
    missing = by_key["fixture_missing_2026"]["bibliographic_integrity_signals"]
    abstract = next(
        item for item in missing if item["tortured_phrase_context"]["surface"] == "cited_abstract"
    )
    title = next(
        item for item in missing if item["tortured_phrase_context"]["surface"] == "cited_title"
    )
    assert title["finding"] == "detected"
    assert abstract["check_status"] == "not_checked"
    assert abstract["finding"] == "unresolved"
    assert abstract["tortured_phrase_context"]["reason_code"] == "ABSTRACT_MISSING"
    assert abstract["tortured_phrase_context"]["counts"]["rules_evaluated"] == 0


def test_whitespace_abstract_is_explicitly_empty_not_checked() -> None:
    document = _passport()
    document["literature_corpus"][0]["abstract"] = " \t\n"
    output = screening.enrich_passport(
        document,
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    abstract = next(
        item
        for item in output["literature_corpus"][0]["bibliographic_integrity_signals"]
        if item["tortured_phrase_context"]["surface"] == "cited_abstract"
    )
    assert abstract["check_status"] == "not_checked"
    assert abstract["finding"] == "unresolved"
    assert abstract["tortured_phrase_context"]["reason_code"] == "ABSTRACT_EMPTY"
    assert abstract["tortured_phrase_context"]["surface_binding"] == {
        "content_sha256": None,
        "content_utf8_bytes": None,
    }
    assert abstract["tortured_phrase_context"]["counts"]["rules_evaluated"] == 0


def test_legitimate_negative_only_means_no_configured_match() -> None:
    output = _enriched()
    entry = next(
        item for item in output["literature_corpus"] if item["citation_key"] == "fixture_negative_2026"
    )
    assert all(
        signal["finding"] == "not_detected"
        for signal in entry["bibliographic_integrity_signals"]
    )
    assert all(
        signal["tortured_phrase_context"]["boundary"]["absence_is_clean_certificate"]
        is False
        for signal in entry["bibliographic_integrity_signals"]
    )


def test_manual_entries_are_not_exempt_and_pointer_is_not_dereferenced() -> None:
    output = _enriched()
    entry = output["literature_corpus"][0]
    assert entry["obtained_via"] == "manual"
    assert entry["source_pointer"].startswith("fixture://")
    assert len(entry["bibliographic_integrity_signals"]) == 2


def test_enrichment_is_semantically_idempotent_and_supersedes_current_row() -> None:
    first = _enriched()
    second = screening.enrich_passport(
        first,
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    assert second == first
    first["literature_corpus"][0]["title"] += " changed"
    third = screening.enrich_passport(
        first,
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    signals = third["literature_corpus"][0]["bibliographic_integrity_signals"]
    assert len([item for item in signals if item["schema_version"] == screening.SIGNAL_VERSION]) == 2


def test_enrichment_rejects_foreign_current_row_before_supersession() -> None:
    document = _enriched()
    row = document["literature_corpus"][0]["bibliographic_integrity_signals"][0]
    row["subject"]["source_pointer"] = "fixture://foreign-source"
    with pytest.raises(screening.ScreeningError, match="source_pointer does not belong"):
        screening.enrich_passport(
            document,
            state=_state(),
            checked_at=CHECKED_AT,
            recorded_at=RECORDED_AT,
        )


def test_legacy_and_unrelated_signals_are_preserved() -> None:
    document = _passport()
    legacy = json.loads(
        (SCRIPTS / "fixtures/bibliographic_integrity_signals/tortured_phrase.json").read_text(
            encoding="utf-8"
        )
    )
    legacy["subject"]["citation_key"] = document["literature_corpus"][0]["citation_key"]
    legacy["subject"]["source_pointer"] = document["literature_corpus"][0]["source_pointer"]
    document["literature_corpus"][0]["bibliographic_integrity_signals"] = [legacy]
    output = screening.enrich_passport(
        document,
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    signals = output["literature_corpus"][0]["bibliographic_integrity_signals"]
    assert signals[0] == legacy
    assert len(signals) == 3


def test_multiple_current_rows_are_rejected() -> None:
    document = _enriched()
    entry = document["literature_corpus"][0]
    duplicate = copy.deepcopy(entry["bibliographic_integrity_signals"][0])
    context = duplicate["tortured_phrase_context"]
    context["snapshot"]["snapshot_sha256"] = "0" * 64
    context["snapshot"]["manifest_sha256"] = "1" * 64
    duplicate["provenance"]["source_sha256"] = "0" * 64
    duplicate["signal_id"] = screening._signal_id(
        entry["citation_key"],
        context["surface"],
        context["snapshot"]["snapshot_sha256"],
        context["surface_binding"]["content_sha256"],
    )
    for match in context["matches"]:
        span = match["source_span"]
        match["match_id"] = "tpm-" + screening._sha256_text(
            screening._canonical_json(
                {
                    "artifact_sha256": context["surface_binding"]["content_sha256"],
                    "snapshot_sha256": context["snapshot"]["snapshot_sha256"],
                    "surface": context["surface"],
                    "segment_id": match["segment_id"],
                    "context": match["context"],
                    "rule_id": match["pattern_id"],
                    "codepoint_start": span["codepoint_start"],
                    "codepoint_end": span["codepoint_end"],
                }
            )
        )[:24]
    entry["bibliographic_integrity_signals"].append(duplicate)
    with pytest.raises(screening.ScreeningError, match="multiple current"):
        screening.enrich_passport(
            document,
            state=_state(),
            checked_at=CHECKED_AT,
            recorded_at=RECORDED_AT,
        )


def test_internally_invalid_current_row_is_not_silently_superseded() -> None:
    document = _enriched()
    row = document["literature_corpus"][0]["bibliographic_integrity_signals"][0]
    row["signal_id"] = row["signal_id"][:-1] + (
        "0" if row["signal_id"][-1] != "0" else "1"
    )
    with pytest.raises(screening.ScreeningError, match="internally inconsistent"):
        screening.enrich_passport(
            document,
            state=_state(),
            checked_at=CHECKED_AT,
            recorded_at=RECORDED_AT,
        )


def test_generated_id_collision_with_preserved_legacy_row_is_rejected() -> None:
    document = _passport()
    generated = screening.build_cited_signal(
        document["literature_corpus"][0],
        surface="cited_title",
        state=_state(),
        checked_at=CHECKED_AT,
        recorded_at=RECORDED_AT,
    )
    legacy = json.loads(
        (SCRIPTS / "fixtures/bibliographic_integrity_signals/tortured_phrase.json").read_text(
            encoding="utf-8"
        )
    )
    legacy["signal_id"] = generated["signal_id"]
    legacy["subject"]["citation_key"] = document["literature_corpus"][0]["citation_key"]
    legacy["subject"]["source_pointer"] = document["literature_corpus"][0]["source_pointer"]
    document["literature_corpus"][0]["bibliographic_integrity_signals"] = [legacy]
    with pytest.raises(screening.ScreeningError, match="collides with preserved"):
        screening.enrich_passport(
            document,
            state=_state(),
            checked_at=CHECKED_AT,
            recorded_at=RECORDED_AT,
        )


@pytest.mark.parametrize(
    "mutation",
    [
        "title",
        "source_pointer",
        "signal_id",
        "span",
        "count",
        "match_id",
        "evidence",
    ],
)
def test_cited_binding_mutations_fail(mutation: str) -> None:
    output = _enriched()
    entry = output["literature_corpus"][0]
    target_surface = "cited_abstract" if mutation == "span" else "cited_title"
    signal = next(
        item
        for item in entry["bibliographic_integrity_signals"]
        if item["tortured_phrase_context"]["surface"] == target_surface
    )
    if mutation == "title":
        entry["title"] += " mutation"
    elif mutation == "source_pointer":
        entry["source_pointer"] += "/mutation"
    elif mutation == "signal_id":
        signal["signal_id"] = signal["signal_id"][:-1] + "0"
    elif mutation == "span":
        signal["tortured_phrase_context"]["matches"][0]["source_span"]["utf8_end"] -= 1
    elif mutation == "count":
        signal["tortured_phrase_context"]["counts"]["rule_match_count"] += 1
    elif mutation == "match_id":
        signal["tortured_phrase_context"]["matches"][0]["match_id"] = "tpm-" + "0" * 24
    else:
        signal["evidence"][0]["observed_value"] = "forged"
    with pytest.raises(screening.ScreeningError):
        screening.validate_cited_signal_binding(signal, entry)


@pytest.mark.parametrize(
    "mutation",
    [
        "missing_abstract_as_checked",
        "checked_with_zero_rules",
        "checked_with_unknown_segment",
        "match_context_crosses_surface",
        "outer_not_checked_with_loaded_snapshot",
        "not_checked_snapshot_keeps_hashes",
        "match_limit_with_not_checked_snapshot",
    ],
)
def test_cited_state_and_surface_laundering_mutations_fail(mutation: str) -> None:
    output = _enriched()
    if mutation == "missing_abstract_as_checked":
        entry = next(
            item
            for item in output["literature_corpus"]
            if item["citation_key"] == "fixture_missing_2026"
        )
        signal = next(
            item
            for item in entry["bibliographic_integrity_signals"]
            if item["tortured_phrase_context"]["surface"] == "cited_abstract"
        )
        signal["check_status"] = "checked"
        signal["finding"] = "not_detected"
        signal["provenance"]["checked_at"] = CHECKED_AT
        signal["evidence"][0]["evidence_type"] = "list_record"
        signal["evidence"][0]["observed_value"] = 0
        signal["tortured_phrase_context"]["reason_code"] = "CHECK_COMPLETED"
    else:
        entry = output["literature_corpus"][0]
        signal = next(
            item
            for item in entry["bibliographic_integrity_signals"]
            if item["tortured_phrase_context"]["surface"] == "cited_title"
        )
        context = signal["tortured_phrase_context"]
        if mutation == "checked_with_zero_rules":
            context["counts"]["rules_evaluated"] = 0
        elif mutation == "checked_with_unknown_segment":
            context["counts"]["unknown_segments"] = 1
        elif mutation == "match_context_crosses_surface":
            match = context["matches"][0]
            match["context"] = "cited_abstract"
            payload = {
                "artifact_sha256": context["surface_binding"]["content_sha256"],
                "snapshot_sha256": context["snapshot"]["snapshot_sha256"],
                "surface": context["surface"],
                "segment_id": match["segment_id"],
                "context": match["context"],
                "rule_id": match["pattern_id"],
                "codepoint_start": match["source_span"]["codepoint_start"],
                "codepoint_end": match["source_span"]["codepoint_end"],
            }
            match["match_id"] = "tpm-" + screening._sha256_text(
                screening._canonical_json(payload)
            )[:24]
            context["counts"]["matches_by_context"]["cited_title"] -= 1
            context["counts"]["matches_by_context"]["cited_abstract"] += 1
        elif mutation in {
            "outer_not_checked_with_loaded_snapshot",
            "not_checked_snapshot_keeps_hashes",
        }:
            signal["check_status"] = "not_checked"
            signal["finding"] = "unresolved"
            signal["provenance"]["checked_at"] = None
            signal["evidence"][0]["evidence_type"] = "degradation_record"
            signal["evidence"][0]["observed_value"] = "SNAPSHOT_NOT_PROVIDED"
            context["reason_code"] = "SNAPSHOT_NOT_PROVIDED"
            context["counts"] = screening._empty_counts()
            context["matches"] = []
            if mutation == "not_checked_snapshot_keeps_hashes":
                context["snapshot"] = screening._snapshot_binding(
                    screening.snapshot_state(None, None)
                )
                context["snapshot"]["snapshot_sha256"] = "0" * 64
                context["snapshot"]["manifest_sha256"] = "1" * 64
                signal["signal_id"] = screening._signal_id(
                    entry["citation_key"],
                    context["surface"],
                    context["snapshot"]["snapshot_sha256"],
                    context["surface_binding"]["content_sha256"],
                )
                signal["provenance"]["source_name"] = (
                    "tortured-phrase snapshot unavailable"
                )
                signal["provenance"]["source_version"] = None
                signal["provenance"]["source_sha256"] = "0" * 64
        else:
            signal["check_status"] = "degraded"
            signal["finding"] = "unresolved"
            signal["evidence"][0]["evidence_type"] = "degradation_record"
            signal["evidence"][0]["observed_value"] = "MATCH_RESOURCE_LIMIT"
            context["reason_code"] = "MATCH_RESOURCE_LIMIT"
            context["counts"] = screening._empty_counts()
            context["matches"] = []
            context["snapshot"] = screening._snapshot_binding(
                screening.snapshot_state(None, None)
            )
            signal["provenance"]["source_name"] = (
                "tortured-phrase snapshot unavailable"
            )
            signal["provenance"]["source_version"] = None
            signal["provenance"]["source_sha256"] = None
    with pytest.raises(screening.ScreeningError):
        screening.validate_cited_signal_binding(signal, entry)


@pytest.mark.parametrize(
    "rights",
    [
        {
            "basis": "user_declared_authorized",
            "redistribution_status": "permitted",
            "reference": None,
            "user_declaration": None,
        },
        {
            "basis": "written_permission",
            "redistribution_status": "permitted",
            "reference": None,
            "user_declaration": None,
        },
        {
            "basis": "unresolved",
            "redistribution_status": "permitted",
            "reference": None,
            "user_declaration": None,
        },
    ],
)
def test_cited_carrier_rejects_impossible_rights_projection(rights: dict) -> None:
    output = _enriched()
    entry = output["literature_corpus"][0]
    signal = entry["bibliographic_integrity_signals"][0]
    signal["tortured_phrase_context"]["snapshot"]["rights"] = rights
    with pytest.raises(screening.ScreeningError):
        screening.validate_cited_signal_binding(signal, entry)


def test_cited_carrier_rejects_missing_loaded_source_locator() -> None:
    output = _enriched()
    entry = output["literature_corpus"][0]
    signal = entry["bibliographic_integrity_signals"][0]
    signal["tortured_phrase_context"]["snapshot"]["source"]["locator"] = None
    with pytest.raises(screening.ScreeningError):
        screening.validate_cited_signal_binding(signal, entry)


def test_tortured_phrase_cannot_be_deterministic_or_terminal() -> None:
    schema = screening._load_schema(screening.SIGNAL_SCHEMA_PATH)
    validator = Draft202012Validator(
        schema, format_checker=Draft202012Validator.FORMAT_CHECKER
    )
    signal = _enriched()["literature_corpus"][0]["bibliographic_integrity_signals"][0]
    assert not list(validator.iter_errors(signal))
    signal["epistemic_class"] = "deterministic_fact"
    signal["epistemic_label"] = "RESOLVER-OR-LIST-OBSERVATION"
    assert list(validator.iter_errors(signal))
    signal = _enriched()["literature_corpus"][0]["bibliographic_integrity_signals"][0]
    signal["terminal_policy"] = {
        "eligible": True,
        "owner": "citation_finalizer",
        "policy_key": "tortured_phrase",
        "current_effect": "policy_gated",
    }
    assert list(validator.iter_errors(signal))


def test_report_never_copies_raw_pattern_bodies() -> None:
    report_bytes = json.dumps(_report(), ensure_ascii=False)
    snapshot = json.loads((FIXTURES / "snapshot.json").read_text(encoding="utf-8"))
    for rule in snapshot["rules"]:
        expression = json.dumps(rule["expression"], ensure_ascii=False, sort_keys=True)
        assert expression not in report_bytes


def test_cli_rejects_in_place_passport_output() -> None:
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "enrich-passport",
            "--input",
            str(FIXTURES / "corpus_input.yaml"),
            "--output",
            str(FIXTURES / "corpus_input.yaml"),
            "--snapshot",
            str(FIXTURES / "snapshot.json"),
            "--snapshot-manifest",
            str(FIXTURES / "snapshot_manifest.json"),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    assert "refuses in-place" in result.stderr


@pytest.mark.parametrize("alias", ["snapshot", "manifest", "snapshot_hardlink"])
def test_scan_output_cannot_alias_any_named_input(
    tmp_path: Path, alias: str
) -> None:
    draft = tmp_path / "draft.md"
    snapshot = tmp_path / "snapshot.json"
    manifest = tmp_path / "manifest.json"
    draft.write_bytes((FIXTURES / "own_draft.md").read_bytes())
    snapshot.write_bytes((FIXTURES / "snapshot.json").read_bytes())
    manifest.write_bytes((FIXTURES / "snapshot_manifest.json").read_bytes())
    if alias == "snapshot":
        output = snapshot
    elif alias == "manifest":
        output = manifest
    else:
        output = tmp_path / "snapshot-hardlink.json"
        output.hardlink_to(snapshot)
    snapshot_before = snapshot.read_bytes()
    manifest_before = manifest.read_bytes()
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "scan-draft",
            "--input",
            str(draft),
            "--artifact-id",
            "draft.md",
            "--format",
            "markdown",
            "--snapshot",
            str(snapshot),
            "--snapshot-manifest",
            str(manifest),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
            "--output",
            str(output),
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    assert "named-input alias" in result.stderr
    assert snapshot.read_bytes() == snapshot_before
    assert manifest.read_bytes() == manifest_before


def test_corpus_output_match_cap_rejects_before_write(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setattr(screening, "MAX_CORPUS_OUTPUT_MATCHES", 0)
    with pytest.raises(screening.MatchLimitError, match="corpus output match count"):
        _enriched()


@pytest.mark.parametrize(
    ("limit_name", "document", "message"),
    [
        (
            "MAX_CORPUS_ENTRIES",
            {"literature_corpus": [{}, {}]},
            "more than 1 entries",
        ),
        (
            "MAX_CORPUS_EXISTING_SIGNALS",
            {"literature_corpus": [{"bibliographic_integrity_signals": [{}]}]},
            "exceed 0 rows",
        ),
    ],
)
def test_corpus_cardinality_caps_fail_before_copy_or_row_construction(
    monkeypatch: pytest.MonkeyPatch,
    limit_name: str,
    document: dict,
    message: str,
) -> None:
    monkeypatch.setattr(screening, limit_name, 1 if limit_name.endswith("ENTRIES") else 0)

    def unexpected_copy(_value):
        raise AssertionError("copy must not run after an over-limit input")

    monkeypatch.setattr(screening.copy, "deepcopy", unexpected_copy)
    with pytest.raises(screening.MatchLimitError, match=message):
        screening.enrich_passport(
            document,
            state=screening.snapshot_state(None, None),
            checked_at=CHECKED_AT,
            recorded_at=RECORDED_AT,
        )


def test_deep_json_passport_fails_closed_without_traceback_or_output_mutation(
    tmp_path: Path,
) -> None:
    passport = tmp_path / "deep-passport.json"
    passport.write_text(
        '{"literature_corpus":[],"extension":'
        + "[" * 1000
        + "0"
        + "]" * 1000
        + "}\n",
        encoding="utf-8",
    )
    output = tmp_path / "output.json"
    output.write_bytes(b"sentinel\n")
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "enrich-passport",
            "--input",
            str(passport),
            "--output",
            str(output),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    assert "Traceback" not in result.stderr
    assert "strict JSON" in result.stderr or "structure exceeds" in result.stderr
    assert output.read_bytes() == b"sentinel\n"


def test_deep_advisory_report_fails_closed_without_traceback(tmp_path: Path) -> None:
    report = tmp_path / "deep-report.json"
    report.write_text(
        '{"extension":' + "[" * 1000 + "0" + "]" * 1000 + "}\n",
        encoding="utf-8",
    )
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "validate-draft",
            "--input",
            str(FIXTURES / "own_draft.md"),
            "--artifact-id",
            "own_draft.md",
            "--format",
            "markdown",
            "--snapshot",
            str(FIXTURES / "snapshot.json"),
            "--snapshot-manifest",
            str(FIXTURES / "snapshot_manifest.json"),
            "--report",
            str(report),
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    assert "Traceback" not in result.stderr
    assert "strict JSON" in result.stderr or "structure exceeds" in result.stderr


@pytest.mark.parametrize("cwd", [REPO_ROOT, SCRIPTS])
def test_runtime_imports_in_package_and_direct_script_modes(cwd: Path) -> None:
    module = "scripts.tortured_phrase_screening" if cwd == REPO_ROOT else "tortured_phrase_screening"
    result = subprocess.run(
        [sys.executable, "-c", f"import {module}"],
        cwd=cwd,
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 0, result.stderr


def test_package_import_cannot_bind_shadow_bibliographic_module(
    tmp_path: Path,
) -> None:
    (tmp_path / "bibliographic_integrity_signals.py").write_text(
        "raise RuntimeError('shadow module imported')\n", encoding="utf-8"
    )
    code = (
        "import sys; "
        f"sys.path.insert(0, {str(tmp_path)!r}); "
        "import scripts.tortured_phrase_screening as module; "
        "print(module._validate_existing_phrase_projection.__module__); "
        "print(module._validate_existing_phrase_projection.__code__.co_filename)"
    )
    result = subprocess.run(
        [sys.executable, "-c", code],
        cwd=REPO_ROOT,
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 0, result.stderr
    lines = result.stdout.splitlines()
    assert lines[0] == "scripts.bibliographic_integrity_signals"
    assert Path(lines[1]).resolve() == (
        SCRIPTS / "bibliographic_integrity_signals.py"
    ).resolve()


def test_yaml_aliases_fail_closed_without_output(tmp_path: Path) -> None:
    passport = tmp_path / "aliased.yaml"
    passport.write_text(
        "shared: &rows []\nliterature_corpus: *rows\n",
        encoding="utf-8",
    )
    output = tmp_path / "output.yaml"
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "enrich-passport",
            "--input",
            str(passport),
            "--output",
            str(output),
            "--snapshot",
            str(FIXTURES / "snapshot.json"),
            "--snapshot-manifest",
            str(FIXTURES / "snapshot_manifest.json"),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    assert "YAML aliases are forbidden" in result.stderr
    assert not output.exists()


def test_cli_has_no_all_or_page_traversal() -> None:
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "render-draft",
            "--help",
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 0
    assert "--all" not in result.stdout
    assert "--page" not in result.stdout


def test_invalid_snapshot_cli_writes_degraded_artifact_and_returns_one(tmp_path: Path) -> None:
    bad = tmp_path / "bad.json"
    bad.write_text("{}\n", encoding="utf-8")
    output = tmp_path / "report.json"
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "scan-draft",
            "--input",
            str(FIXTURES / "own_draft.md"),
            "--artifact-id",
            "own_draft.md",
            "--format",
            "markdown",
            "--snapshot",
            str(bad),
            "--snapshot-manifest",
            str(FIXTURES / "snapshot_manifest.json"),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
            "--output",
            str(output),
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    report = json.loads(output.read_text(encoding="utf-8"))
    assert report["check_status"] == "degraded"
    assert report["finding"] == "unresolved"


@pytest.mark.parametrize(
    ("text", "reason"),
    [
        ("", "DOCUMENT_EMPTY"),
        ("`unclosed luminous turnip", "DOCUMENT_PARSE_DEGRADED"),
    ],
)
def test_loaded_snapshot_scan_returns_one_for_degraded_artifact(
    tmp_path: Path, text: str, reason: str
) -> None:
    draft = tmp_path / "draft.md"
    draft.write_text(text, encoding="utf-8")
    output = tmp_path / "report.json"
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "scan-draft",
            "--input",
            str(draft),
            "--artifact-id",
            "draft.md",
            "--format",
            "markdown",
            "--snapshot",
            str(FIXTURES / "snapshot.json"),
            "--snapshot-manifest",
            str(FIXTURES / "snapshot_manifest.json"),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
            "--output",
            str(output),
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    report = json.loads(output.read_text(encoding="utf-8"))
    assert report["check_status"] == "degraded"
    assert report["reason_code"] == reason


def test_loaded_snapshot_resource_degradation_returns_one_after_write(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    draft = tmp_path / "draft.md"
    draft.write_text("alpha\n\nbeta", encoding="utf-8")
    output = tmp_path / "report.json"
    monkeypatch.setattr(screening, "MAX_SEGMENTS", 1)
    result = screening.main(
        [
            "scan-draft",
            "--input",
            str(draft),
            "--artifact-id",
            "draft.md",
            "--format",
            "markdown",
            "--snapshot",
            str(FIXTURES / "snapshot.json"),
            "--snapshot-manifest",
            str(FIXTURES / "snapshot_manifest.json"),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
            "--output",
            str(output),
        ]
    )
    assert result == 1
    report = json.loads(output.read_text(encoding="utf-8"))
    assert report["check_status"] == "degraded"
    assert report["reason_code"] == "MATCH_RESOURCE_LIMIT"


def test_loaded_snapshot_corpus_degradation_returns_one_after_write(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
) -> None:
    passport = tmp_path / "corpus.yaml"
    passport.write_bytes((FIXTURES / "corpus_input.yaml").read_bytes())
    output = tmp_path / "output.yaml"
    monkeypatch.setattr(screening, "MAX_MATCH_WORK_UNITS", 0)
    result = screening.main(
        [
            "enrich-passport",
            "--input",
            str(passport),
            "--output",
            str(output),
            "--snapshot",
            str(FIXTURES / "snapshot.json"),
            "--snapshot-manifest",
            str(FIXTURES / "snapshot_manifest.json"),
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
        ]
    )
    assert result == 1
    enriched, _kind = screening._load_passport(output)
    assert any(
        signal.get("check_status") == "degraded"
        for entry in enriched["literature_corpus"]
        for signal in entry["bibliographic_integrity_signals"]
        if signal.get("schema_version") == screening.SIGNAL_VERSION
    )


def test_explicit_not_checked_scan_remains_successful(tmp_path: Path) -> None:
    output = tmp_path / "report.json"
    result = screening.main(
        [
            "scan-draft",
            "--input",
            str(FIXTURES / "own_draft.md"),
            "--artifact-id",
            "own_draft.md",
            "--format",
            "markdown",
            "--checked-at",
            CHECKED_AT,
            "--recorded-at",
            RECORDED_AT,
            "--output",
            str(output),
        ]
    )
    assert result == 0
    assert json.loads(output.read_text(encoding="utf-8"))["check_status"] == (
        "not_checked"
    )


def test_failed_scan_does_not_overwrite_input_or_partial_output(tmp_path: Path) -> None:
    draft = tmp_path / "draft.md"
    draft.write_text("luminous turnip", encoding="utf-8")
    before = draft.read_bytes()
    result = subprocess.run(
        [
            sys.executable,
            str(SCRIPTS / "tortured_phrase_screening.py"),
            "scan-draft",
            "--input",
            str(draft),
            "--artifact-id",
            "draft.md",
            "--format",
            "markdown",
            "--checked-at",
            "bad-time",
            "--recorded-at",
            RECORDED_AT,
            "--output",
            str(tmp_path / "report.json"),
        ],
        text=True,
        capture_output=True,
        check=False,
    )
    assert result.returncode == 1
    assert draft.read_bytes() == before
    assert not (tmp_path / "report.json").exists()