imbad0202__academic-research-skills/scripts/check_phase_conformance.py

#!/usr/bin/env python3
"""Fail-closed Phase 1 -> Phase 2 conformance checker for reviewer Schema 13.2.

Usage:
  python scripts/check_phase_conformance.py --contract C.json --role eic \
      --phase1 eic.phase1.md --phase2 eic.phase2.md \
      --manuscript manuscript.md --metadata metadata.json

Exit 0 pass, 2 contract/infra failure, 3 reviewer conformance failure.
"""
from __future__ import annotations

import argparse
import html
import json
import re
import sys
import unicodedata
from collections import Counter
from dataclasses import dataclass
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
import check_panel_synthesis as panel  # noqa: E402
import recompute_receipts as recompute  # noqa: E402

EXIT_PASS = 0
EXIT_CONTRACT = 2
EXIT_CONFORMANCE = 3
_METADATA_KEYS = frozenset({"title", "field", "word_count"})
_FIELD_PATTERNS = {
    "dimension_id": re.compile(r"^dimension_id: (?P<value>D\d+)$"),
    "what_to_look_for": re.compile(r"^what_to_look_for: (?P<value>\S.*)$"),
    "what_triggers_block": re.compile(
        r"^what_triggers_block: (?P<value>\S.*)$"
    ),
    "what_triggers_warn": re.compile(
        r"^what_triggers_warn: (?P<value>\S.*)$"
    ),
    "what_triggers_fatal": re.compile(
        r"^what_triggers_fatal: (?P<value>\S.*)$"
    ),
}
_DISSENT_DIM_RE = re.compile(r"^dimension_id: (?P<dim>D\d+)\s*$")
_DISSENT_RATIONALE_RE = re.compile(r"^rationale: (?P<text>\S.*)\s*$")
_SEVERITY_RE = re.compile(
    r"(?:^|\|\s*)\s*(?:[-*]\s*)?\*\*Severity\*\*:\s*"
    r"(?P<severity>Critical|Major|Minor)\b"
)
_ANCHOR_RE = re.compile(
    r"(?:^|\|\s*)\s*(?:[-*]\s*)?\*\*Evidence Anchor\*\*:\s*"
    r"(?P<value>[^|]+)"
)
_SEVERITY_DECL_RE = re.compile(
    r"\*\*Severity(?:\*\*)?\s*:",
    re.IGNORECASE,
)
_ANCHOR_DECL_RE = re.compile(
    r"\*\*Evidence Anchor(?:\*\*)?\s*:",
    re.IGNORECASE,
)
_FINDING_H3_RE = re.compile(r"^W[1-9]\d*: \S.*$")
# --- #610 methodology arithmetic-receipt grammar -------------------------
# Receipt machine lines are lowercase snake_case on purpose: they can never
# collide with the finding grammar's bold `**Severity**:` / `**Evidence
# Anchor**:` declarations, so the receipt section cannot trip the
# outside-Review-Body severity gate and a finding cannot satisfy a receipt
# field. Decoration tolerance is bounded to the two shapes the finding
# grammar already accepts (one leading list marker, bold around the key).
# The section is read fence-transparently (#637/#638 display-form
# discipline): a fenced receipt line is still content, so a stylistic fence
# neither hides a receipt nor turns one into a false abort, and any other
# decoration of a field-shaped line is detected and aborts loudly instead of
# silently passing a forbidden-field guard or failing a required count.
_RECEIPT_SECTION = "Arithmetic Receipts"
_RECEIPT_H3_RE = re.compile(r"^AR[1-9]\d*$")
_RECEIPT_PROCEDURES = frozenset(
    {"p_from_test_statistic", "grim", "grimmer", "n_from_df"}
)
_RECEIPT_STATUSES = frozenset(
    {"consistent", "mismatch", "not_computable", "not_applicable"}
)
_NOT_COMPUTABLE_REASONS = frozenset({
    "missing_reported_value",
    "test_family_ambiguous",
    "tail_ambiguous",
    "nonstandard_p_procedure",
    "inequality_unresolvable",
    "rounding_rule_ambiguous",
    "rounding_boundary_ambiguous",
    "scale_granularity_unknown",
    "scale_support_unknown",
    "analytic_n_ambiguous",
    "aggregation_or_weighting_unknown",
    "sd_convention_unknown",
    "mean_grim_inconsistent",
    "df_identity_ambiguous",
    "model_correction_or_pooling",
    "reachability_not_completed",
})
_TAIL_CONVENTIONS = frozenset(
    {"two-tailed", "one-tailed", "upper-tail", "unstated"}
)


def _receipt_field_re(key: str) -> re.Pattern[str]:
    # Bold is balanced-or-absent: a half-bold `**key:` is a decorated line
    # for the shape guard to abort, never a canonical field (#610 round-2).
    return re.compile(
        rf"^(?:[-*] )?(?:{key}|\*\*{key}\*\*): (?P<value>\S.*?)\s*$"
    )


_RECEIPT_FIELD_RES = {
    key: _receipt_field_re(key)
    for key in (
        "procedure_id",
        "evidence_anchor",
        "reported_inputs",
        "assumptions",
        "derivation",
        "derived_value_or_range",
        "comparison_rule",
        "status",
        "not_computable_reason",
        "finding_ref",
        "tail_convention",
        "rounding_interval",
        "nearest_achievable",
        "df_identity",
    )
}
_RECEIPT_ATTESTATION_RE = _receipt_field_re("no_recomputable_statistics")
_RECEIPT_ATTESTATION_ADVISORY = (
    "[RECEIPT-ATTESTATION: declaration-only — applicability not "
    "machine-verified; adjudication judges the attestation]"
)
# Folded field-name alphabets for the decoration-agnostic shape test, the
# same construction as `_is_dissent_field_shaped`: a line is receipt-field-
# shaped when the letters before its first colon spell a field name after
# markup-span strip + NFKC fold. A shaped line that the canonical grammar
# does not parse is a loud abort, never a silently ignored decoration.
_RECEIPT_FIELD_SHAPE_NAMES = frozenset(
    "".join(char for char in key if char.isalpha())
    for key in (*_RECEIPT_FIELD_RES, "no_recomputable_statistics")
)
_FINDING_REF_VALUE_RE = re.compile(r"^W[1-9]\d*$")
# The back-reference value is exact: `AR<n>` up to end-of-line or the next
# table pipe. `AR1, AR2` and trailing prose fail this parse and then abort
# via the lenient declaration count below rather than half-reading `AR1`.
_RECEIPT_BACKREF_RE = re.compile(
    r"(?:^|\|\s*)\s*(?:[-*]\s*)?\*\*Arithmetic Receipt\*\*:\s*"
    r"(?P<value>AR[1-9]\d*)\s*(?=\||$)"
)
# Lenient declaration shape for the back-reference, checked against the
# canonical parse per line (`_is_dissent_field_shaped` construction): a line
# whose letters before the first colon spell exactly `arithmeticreceipt` is
# a declaration the seat made, so a decorated, fenced, or prose-trailed
# back-reference the canonical regex refuses aborts instead of vanishing.
# Prose that merely mentions the section (`the Arithmetic Receipts
# section: ...`) carries extra letters in its head and stays prose.
_RECEIPT_BACKREF_SHAPE_NAME = "arithmeticreceipt"
# Both-tails value rule (#610 rounds 1-2): under an unstated tail, each tail
# label must share its own `;`-delimited segment of `derived_value_or_range`
# with a digit — either side of the label, so `p = .192 (two-tailed)` is a
# shown value while a bare label in a digitless segment is not. Hyphen
# variants (space, ASCII hyphen, U+2010-U+2015) are folded into the label
# match, the value text is NFKC-folded first, and the label needs letter
# boundaries so `notwo-tailed` prose cannot satisfy the rule; a fused
# `twotailed` typo still counts as the label — it carries its value, and
# rejecting it would be a false abort on an unretryable phase.
_TAIL_LABEL_RES = {
    label: re.compile(rf"(?<![a-z]){label}[\s‐-―-]?tailed(?![a-z])")
    for label in ("two", "one")
}
# Conditional-field matrix, spec §4/§5 (2026-08-02 #610 spec): which
# procedure-specific lines each procedure may carry. `tail_convention` is
# required on every p_from_test_statistic receipt (what the paper states is
# always statable — `unstated` exists for exactly that case); the completed-
# procedure fields (`rounding_interval`, `nearest_achievable`, `df_identity`)
# are required only under a verdict status, because `not_computable` may
# legitimately stop before the field can exist, and remain permitted there
# for a partial attempt that stopped late.
_RECEIPT_VERDICT_STATUSES = frozenset({"consistent", "mismatch"})
_PROCEDURE_FIELDS = {
    "p_from_test_statistic": ("tail_convention",),
    "grim": ("rounding_interval", "nearest_achievable"),
    "grimmer": ("rounding_interval", "nearest_achievable"),
    "n_from_df": ("df_identity",),
}
# Inverted view driving the conditional-field loop, so the matrix above is
# the single authority: field -> the procedures that carry it.
_PROCEDURE_FIELD_OWNERS = {
    field: tuple(
        procedure
        for procedure, fields in _PROCEDURE_FIELDS.items()
        if field in fields
    )
    for fields in _PROCEDURE_FIELDS.values()
    for field in fields
}
_ALWAYS_REQUIRED_PROCEDURE_FIELDS = frozenset({"tail_convention"})
# --- end #610 receipt grammar --------------------------------------------
_DISSENT_FIELD_NAMES = frozenset({"dimensionid", "rationale"})
_MARKUP_SPAN_RE = re.compile(
    r"<[^>]*>|\]\((?:[^()]|\([^()]*\))*\)|\]\[[^\]]*\]|\[[ xX]?\]"
)
# Non-comment raw HTML is forbidden only inside the dissent span (#682).
# Match the opening delimiter rather than requiring a complete tag: CommonMark
# raw blocks such as a line ending in ``<script`` can still hide the canonical
# fields below it, and a malformed claimed dissent must abort rather than fall
# through to the empty-section advisory.  Autolinks such as
# ``<https://example.test>`` do not match because ``:`` is not a tag-name
# boundary.  Comment delimiters remain owned by the #613 state machine so its
# more specific ``[DISSENT-HIDDEN]`` diagnostic keeps precedence.
_DISSENT_RAW_HTML_RE = re.compile(
    r"<(?:(?:/?[A-Za-z][A-Za-z0-9-]*)(?=[\s/>]|$)|![A-Za-z]|!\[CDATA\[|\?)",
    re.IGNORECASE,
)
# A block opener, including one behind list or blockquote markers: rendered
# through CommonMark, `- <!--` opens raw HTML just as a bare `<!--` does, and
# needs no closer to swallow the rest of the item. The indentation allowances
# must not add up to four, which would make the whole line indented code: a
# list marker takes one to four following spaces before its content, a block
# quote at most one, and a block start may still be indented up to three
# inside the quote it opens. Erring narrow costs a miss; erring wide aborts a
# valid card. Only an ordered list beginning at 1 may interrupt an open
# paragraph, so `2. <!--` under a paragraph line is text, not a list opening
# a raw-HTML block, and the fields below it stay on the page.
def _container_prefix(ordered: str) -> str:
    """Matched against a tab-expanded line, so spaces are the only gap.

    Every gap is one unambiguous run: letting a single space be claimed by
    either of two adjacent optional groups gave two ways to match each marker
    and doubled the work per nesting level, so a short nested quote stalled
    the checker rather than returning a verdict.
    """
    return rf"(?:(?:[-*+]|{ordered}) {{1,4}}|> {{0,4}})*"


# Lines that end the paragraph above them, so the NEXT line sits at a real
# block start where any ordered marker may open a list. An ATX heading of any
# level, a thematic break, and a lone `-` do that from either state, the last
# because it reads as a setext underline under a paragraph and as an empty
# list item without one. A bare `>` starts a container rather than closing a
# paragraph and is left to #613 with the rest of the container family.
_CLOSES_PARAGRAPH_RE = re.compile(
    r"^ {0,3}(?:"
    r"#{1,6}(?:[ \t].*)?$"
    r"|(?:\*[ \t]*){3,}$|(?:_[ \t]*){3,}$|(?:-[ \t]*){3,}$"
    r"|-[ \t]*$"
    r")"
)
# A `=` run or two-or-more hyphens underlines a paragraph, so it closes one
# only when there is a paragraph to underline; with none, it is ordinary
# paragraph text and OPENS one.
_SETEXT_UNDERLINE_RE = re.compile(r"^ {0,3}(?:=+|-{2,})[ \t]*$")
# An empty list item has a blank first line, so it cannot interrupt an open
# paragraph. It only holds the state down where none is open. Reading every
# lone marker as a closer looked symmetrical and aborted valid cards.
_EMPTY_LIST_ITEM_RE = re.compile(r"^ {0,3}(?:[*+]|\d{1,9}[.)])[ \t]*$")
_ANY_ORDERED_MARKER = r"\d{1,9}[.)]"
_PARAGRAPH_INTERRUPTING_MARKER = r"1[.)]"
_COMMENT_OPENER_RE = re.compile(
    rf"^ {{0,3}}{_container_prefix(_ANY_ORDERED_MARKER)}<!--"
)
_PARAGRAPH_OPENER_RE = re.compile(
    rf"^ {{0,3}}{_container_prefix(_PARAGRAPH_INTERRUPTING_MARKER)}<!--"
)


class ConformanceError(Exception):
    """Reviewer conformance failure -> exit 3."""


@dataclass
class PhaseOnePlan:
    commitments: dict[str, dict[str, str]]
    warnings: list[str]


@dataclass
class DissentSpan:
    """The dissent section as written: every line, plus the commented ones.

    `strip_fences` leaves HTML comments in place, so a canonical field inside
    `<!-- ... -->` otherwise parses as a real dissent and collects the
    trigger-binding exemption while the visible card claims nothing.
    """

    lines: list[str]
    hidden_by_comment: list[str]
    raw_html: list[str]


@dataclass
class DissentParse:
    dimensions: set[str]
    diagnostics: list[str]


def _normalise(text: str) -> str:
    return " ".join(text.casefold().split())


def _is_dissent_field_shaped(line: str) -> bool:
    """True when a line spells a dissent field, canonically or decorated.

    Decoration-agnostic by construction: a line is field-shaped when the
    letters preceding its first colon spell exactly a field name, whatever
    non-letters surround them. Enumerating Markdown wrappers instead would
    leave the next unenumerated wrapper (task item, table cell, link label)
    reading as prose. Folded first so a fullwidth re-spelling cannot pass.

    Markup spans carrying letters of their own (HTML tags, reference targets,
    task-list markers, and link destinations up to one nesting level deep) are
    dropped BEFORE the colon is located, not after: an absolute link target
    carries its own `https:` and would otherwise win the partition.

    Decoration beyond those — a deeper nested destination, a quoted HTML
    attribute containing `>`, exotic custom syntax — is deliberately out of
    scope, because absorbing it costs one advisory-flagged record while a
    broader rule costs false aborts, which is the failure this tolerance
    exists to remove. `test_a_nested_paren_link_destination_is_a_declared_
    limit` pins that boundary so it cannot move by accident.

    `str.isalpha` keeps every script's letters, so CJK prose that happens to
    name a field stays prose rather than collapsing onto the field name and
    aborting a panel it should tolerate.
    """
    stripped = _MARKUP_SPAN_RE.sub(
        "", unicodedata.normalize("NFKC", line).casefold()
    )
    head, separator, _ = stripped.partition(":")
    label = "".join(char for char in head if char.isalpha())
    return bool(separator) and label in _DISSENT_FIELD_NAMES


def _display_fold(line: str) -> str:
    """Unescape HTML entities FIRST, then NFKC-fold and casefold.

    Order matters (#610 round-3 P1): a fullwidth-colon entity `&#xFF1A;`
    decodes to a fullwidth colon that only the SUBSEQUENT NFKC fold maps to
    `:`, so folding before unescaping left the decoded colon unfolded and
    the declaration unseen. A doubly-encoded or fullwidth-ampersand entity
    stays literal, which matches what the renderer shows.
    """
    return unicodedata.normalize("NFKC", html.unescape(line)).casefold()


_ESCAPED_PIPE_RE = re.compile(r"\\\|")
# CommonMark §2.4: a backslash escapes the next punctuation character, so
# `\\` is a literal backslash and ``\` `` a literal backtick that can
# neither open nor close a code span. One left-to-right pass sequences the
# two correctly (`\\` consumes its backslash before a following backtick is
# considered). Ignoring this let an escaped-backtick "span" blank a live
# `<!--` and credit a hidden dissent field (#613 security round 1, P1).
_ESCAPED_BACKTICK_RE = re.compile(r"\\[\\`]")


def _blank_code_spans(line: str) -> str:
    """Blank CommonMark inline code spans, matching runs of EQUAL length.

    A regex accepting unequal delimiter runs (#610 round-4 P1) blanked
    from a single-backtick opener to a double-backtick closer — a stretch
    the renderer does NOT treat as code, re-opening the later-cell attack
    — and conversely swallowed legitimate prose. This scanner pairs an
    opening run only with the next run of exactly its length, as the
    renderer does; an unmatched run stays literal. Backslash-escaped
    backticks are blanked FIRST: they are literal to the renderer and must
    not participate in pairing.
    """
    line = _ESCAPED_BACKTICK_RE.sub("  ", line)
    out: list[str] = []
    index, length = 0, len(line)
    while index < length:
        if line[index] != "`":
            out.append(line[index])
            index += 1
            continue
        run_end = index
        while run_end < length and line[run_end] == "`":
            run_end += 1
        run = run_end - index
        scan, close = run_end, -1
        while scan < length:
            if line[scan] != "`":
                scan += 1
                continue
            candidate_end = scan
            while candidate_end < length and line[candidate_end] == "`":
                candidate_end += 1
            if candidate_end - scan == run:
                close = scan
                break
            scan = candidate_end
        if close >= 0:
            out.append(" " * (close + run - index))
            index = close + run
        else:
            out.append(line[index:run_end])
            index = run_end
    return "".join(out)


def _cell_split_form(line: str) -> str:
    """The line with pipe-bearing non-cell constructs blanked for splitting.

    A naive `split("|")` read the pipe inside a Markdown link destination,
    an escaped `\\|`, or an inline code span as a GFM cell boundary and
    minted a phantom field-shaped cell out of legitimate prose — a false
    abort on an unretryable phase (#610 round-3). Those spans are literal
    or non-tabular to the renderer, so they are blanked before the split;
    the whole-line candidate is always tested unmodified.
    """
    blanked = _MARKUP_SPAN_RE.sub(" ", line)
    blanked = _blank_code_spans(blanked)
    return _ESCAPED_PIPE_RE.sub(" ", blanked)


def _is_receipt_field_shaped(line: str) -> bool:
    """True when a line spells a receipt machine field, however decorated.

    Same construction as `_is_dissent_field_shaped` (#610 round-1 fix 4):
    markup spans are stripped, the line is NFKC-folded and HTML-unescaped
    (an entity colon `&#58;` renders as a colon and must read as one), and
    the letters before the first colon must spell exactly a receipt field
    name. An unenumerated decoration — `**status:** mismatch`, a table
    cell, an indented, ordered, or blockquoted marker — is therefore a
    declaration the seat made, and a shaped line the canonical grammar
    refuses aborts loudly instead of silently passing a forbidden-field
    guard or starving a required-field count.
    """
    stripped = _MARKUP_SPAN_RE.sub("", _display_fold(line))
    head, separator, _ = stripped.partition(":")
    label = "".join(char for char in head if char.isalpha())
    return bool(separator) and label in _RECEIPT_FIELD_SHAPE_NAMES


def _receipt_shape_candidates(line: str) -> list[str]:
    """The line plus, when it carries pipes, each `|`-delimited cell.

    The head-of-line shape test alone lets a machine declaration hide in a
    LATER table cell (`| note | **tail_convention:** two-tailed |`), where
    the head letters of the whole line spell nothing (#610 round-2). Cells
    are scanned only when the line does not canonically parse, so a
    canonical field whose free-text value happens to contain a pipe is
    never re-partitioned against itself.
    """
    if "|" not in line:
        return [line]
    return [line, *_cell_split_form(line).split("|")]


def _tail_value_shown(derived_fold: str, label_re: re.Pattern[str]) -> bool:
    """Whether a tail label shares a `;`-delimited segment with a digit.

    Segments are the `;`-delimited pieces of the (NFKC-folded, casefolded)
    `derived_value_or_range` value: a bare label whose number sits in some
    other segment — or nowhere — is a label, not a shown value, and cannot
    satisfy the both-tails display rule. Digit-adjacency is direction-free
    within the segment (`two-tailed p ≈ .192` and `p = .192 (two-tailed)`
    both show the value); the one-pass any() also keeps the scan linear.
    """
    return any(
        label_re.search(segment)
        and any(char.isdigit() for char in segment)
        for segment in derived_fold.split(";")
    )


def _is_backref_shaped(line: str) -> bool:
    """True when a line spells the `**Arithmetic Receipt**:` field, however
    decorated — the same head shape test as the receipt fields."""
    stripped = _MARKUP_SPAN_RE.sub("", _display_fold(line))
    head, separator, _ = stripped.partition(":")
    label = "".join(char for char in head if char.isalpha())
    return bool(separator) and label == _RECEIPT_BACKREF_SHAPE_NAME


def _strip_inline_comment_spans(
    line: str, open_: bool
) -> tuple[str, list[str], bool]:
    """(rendered remainder, hidden segments, state) for inline spans.

    The block visibility model deliberately refuses to read a mid-paragraph
    `prose <!--` as an opener (see `_raw_dissent_span`), but CommonMark
    treats it as raw inline HTML whose comment hides everything until
    `-->`. The Review Body backref walk therefore strips those spans and
    parses only what the renderer shows (#610 rounds 3-5): content after
    the opener on the SAME line is stripped too, and content after a
    closing `-->` on the same line is kept and parsed — so a hidden
    back-reference is never credited and a rendered one is never dropped.
    The hidden segments are returned as well, because a declaration inside
    a span must abort even when the line also carries visible content —
    silently dropping it re-opened the hidden-declaration channel one
    partial-visibility case at a time (#610 round-5). They stay one entry
    PER SPAN, never joined (#610 round-6): joining let a prose span prefix
    shield a declaration in the next span, and conversely synthesized a
    phantom declaration out of harmless fragments. Callers pass a
    code-span-blanked line, matching the renderer's precedence of code
    spans over raw HTML.
    """
    visible_parts: list[str] = []
    hidden_segments: list[str] = []
    index, state = 0, open_
    while True:
        token = "-->" if state else "<!--"
        position = line.find(token, index)
        if position < 0:
            if state:
                hidden_segments.append(line[index:])
            else:
                visible_parts.append(line[index:])
            return "".join(visible_parts), hidden_segments, state
        if state:
            hidden_segments.append(line[index:position])
        else:
            visible_parts.append(line[index:position])
        state, index = not state, position + len(token)


def _backref_declared_count(line: str) -> int:
    """Back-reference declarations on the line, counted per table cell.

    Counting the whole line once let a malformed second declaration ride
    beside a canonical one (`… AR1 | **Arithmetic Receipt:** see AR2`) —
    the canonical parse found a match, the shape test never ran, and the
    visible second declaration vanished (#610 round-2). Cells are the
    declaration slots the canonical regex itself recognises (its
    start-or-pipe prefix), so declared-vs-parsed equality is exact.
    """
    if "|" not in line:
        return 1 if _is_backref_shaped(line) else 0
    return sum(
        1 for cell in _cell_split_form(line).split("|")
        if _is_backref_shaped(cell)
    )


def _lines_with_fence_state(text: str):
    """Yield every line with whether it sits inside a fenced block.

    Mirrors the fence bookkeeping of `panel.strip_fences`, which drops those
    lines rather than reporting them. The dissent scan needs both facts: the
    content, so a fenced field cannot hide, and the state, so a fenced heading
    is not mistaken for a section boundary.

    Fenced lines are yielded in DISPLAY form: CommonMark strips up to the
    opener's indentation from every content line of an indented fence, so a
    consumer reading fenced content (the receipt gate) sees what the page
    shows rather than false-aborting on the indent (#610 round-2).
    """
    fence_char, fence_len, fence_indent = None, 0, 0
    for line in panel._COMMONMARK_LINE_END_RE.split(text):
        if fence_char is not None:
            if match := panel._FENCE_CLOSE_RE.fullmatch(line):
                token = match.group("fence")
                if token[0] == fence_char and len(token) >= fence_len:
                    fence_char, fence_len, fence_indent = None, 0, 0
                    continue
            leading = len(line) - len(line.lstrip(" "))
            yield line[min(fence_indent, leading):], True
            continue
        if match := panel._FENCE_OPEN_RE.fullmatch(line):
            token, info = match.group("fence"), match.group("info")
            if token[0] != "`" or "`" not in info:
                fence_char, fence_len = token[0], len(token)
                fence_indent = len(line) - len(line.lstrip(" "))
                continue
        yield line, False


def _opens_comment(line: str, *, paragraph_open: bool) -> bool:
    """Whether the line starts an HTML comment at a block position.

    Tabs are measured to the next four-column stop rather than counted as one
    character, the way CommonMark reads them wherever indentation defines
    block structure. Counting characters put `> \\t<!--` (column four, a live
    comment) and `  - \\t<!--` (column eight, indented code) on the wrong
    sides of the boundary in opposite directions.

    With a paragraph open, an ordered marker other than 1 cannot start a list,
    so it cannot open a comment either.
    """
    pattern = _PARAGRAPH_OPENER_RE if paragraph_open else _COMMENT_OPENER_RE
    return bool(pattern.match(line.expandtabs(4)))


def _comment_state_after(
    line: str, *, commented: bool, paragraph_open: bool = False
) -> bool:
    """Whether the line ends inside an HTML comment.

    Resolved by delimiter ORDER, not by presence: `<!-- a --> <!--` closes
    and reopens on one line, and reading that as closed credited a comment
    carrying canonical fields as a real dissent. Only a block opener starts
    one, list and blockquote markers included, so a marker discussed mid-line
    is still not a comment; once a line has opened one, its later delimiters
    are that same block's raw HTML.

    The closer may reuse the opener's own last two dashes, which is how
    CommonMark closes `<!-->` and `<!--->`. Ordering the scan without that
    overlap would read them as unterminated and abort a card that presence-
    testing for a closer had passed.
    """
    index = 0
    if not commented:
        if not _opens_comment(line, paragraph_open=paragraph_open):
            return False
        # Located in the ORIGINAL line: the prefix carries no `<!--`, so the
        # first occurrence is the opener wherever tab expansion moved it.
        commented, index = True, line.find("<!--") + 2
    while True:
        token = "-->" if commented else "<!--"
        position = line.find(token, index)
        if position < 0:
            return commented
        commented, index = not commented, position + len(token)


def _inline_comment_state_after(line: str, *, commented: bool) -> bool:
    """Delimiter-order comment state with NO block-position requirement.

    Span-scoped (#613): inside the dissent span the output grammar makes a
    bare ``<!--`` out-of-grammar prose — the delivered Phase 2 prompts and
    the protocol now require inline code for any mention — so every
    occurrence is an opener, including the two CommonMark shapes the block
    visibility model deliberately does not read (a marker following text on
    its own line; a marker indented as a lazy paragraph continuation).
    Callers blank code spans first, so the sanctioned inline-code mention
    never opens.
    """
    index = 0
    while True:
        token = "-->" if commented else "<!--"
        position = line.find(token, index)
        if position < 0:
            return commented
        commented = not commented
        # After an opener, resume at +2 rather than +4: the closer may
        # reuse the opener's own last two dashes (`<!-->`, `<!--->`) —
        # the same overlap rule the block scanner applies (codex #650
        # round 1, P2: skipping it left the empty comment "open" and
        # false-aborted the rendered fields below it).
        index = position + (2 if commented else len(token))


def _lines_with_hidden_state(text: str):
    """Yield (line, fenced, hidden): fence plus HTML-comment visibility.

    The comment and paragraph bookkeeping mirror `_raw_dissent_span` line
    for line, so the receipt gate and the dissent gate share one visibility
    model (#610 round-2, both tracks): `hidden` is True when the line sits
    inside — or itself opens — an HTML comment at a block position, i.e.
    when a CommonMark renderer would not display it. `code_indented` is
    True when the line starts an indented code block (four columns at a
    block position, no paragraph open), i.e. when the renderer shows it as
    literal text rather than a field line (#610 round-3). Fence state is
    layered first, exactly as in `_raw_dissent_span`: a comment marker
    inside a fence is literal text and advances no comment state.
    """
    commented = False
    paragraph_open = False
    for line, fenced in _lines_with_fence_state(text):
        entered_commented = commented
        opens_comment = not fenced and _opens_comment(
            line, paragraph_open=paragraph_open
        )
        if not fenced:
            commented = _comment_state_after(
                line, commented=commented, paragraph_open=paragraph_open
            )
        expanded = line.expandtabs(4)
        code_indented = (
            not fenced
            and not paragraph_open
            and bool(line.strip(" \t"))
            and expanded.startswith("    ")
        )
        state_dependent = (
            _SETEXT_UNDERLINE_RE if paragraph_open else _EMPTY_LIST_ITEM_RE
        )
        closes_paragraph = bool(
            _CLOSES_PARAGRAPH_RE.match(expanded)
            or state_dependent.match(expanded)
        )
        paragraph_open = (
            not fenced
            and bool(line.strip(" \t"))
            and not closes_paragraph
            and not (entered_commented or opens_comment)
            # An indented-code line is literal, never a paragraph: letting
            # it open one made the NEXT code line read as a live paragraph
            # continuation and earn credit the renderer does not show
            # (#610 round-4).
            and not code_indented
        )
        yield line, fenced, entered_commented or opens_comment, code_indented


def _raw_dissent_span(text: str) -> DissentSpan:
    """Dissent-section lines as written, before any sanitizer runs.

    Comment delimiters are opened up rather than dropped, so a field inside an
    HTML comment is scanned instead of vanishing with the comment. A
    field-shaped H2 immediately inside the span rides along, because a field
    spelled as its own `## dimension_id: D1` heading leaves the section body
    empty and would otherwise be invisible; a field-shaped heading anywhere
    else is an ordinary extra section, which the report grammar permits.

    Only an unfenced heading delimits the span, so a heading written inside a
    fenced block cannot end it early and hide the fields that follow — not
    even one repeating a title that exists structurally elsewhere. A COMMENTED
    heading still delimits, agreeing with `split_sections` rather than second-
    guessing it: disagreeing cost four false aborts across review rounds and
    bought only a miss that credits the seat nothing, while agreeing keeps a
    comment opened above the heading from laundering the fields below it.
    """
    span, hidden_by_comment, raw_html = [], [], []
    inside, commented = False, False
    paragraph_open = False
    # #613: span-scoped inline comment state. Outside the span, only a
    # block-position opener counts (the #612 model, unchanged, because
    # prose there may legitimately mention a bare marker). INSIDE the span
    # the delivered output grammar requires inline code for any mention, so
    # a bare `<!--` is an opener wherever it appears — closing the two
    # residual shapes (#613): a marker following text on its own line, and
    # a marker indented as a lazy paragraph continuation.
    span_inline = False
    # Code spans pair by equal-length runs ACROSS soft line breaks within a
    # paragraph, which a per-line blanker cannot see: a trailing unpaired
    # run on one line can pair into the next line and pull a `<!--` out of
    # (or into) code (#613 security round 1, P1). Once a span line leaves
    # an odd number of backtick runs, local blanking is untrustworthy for
    # the REST of that paragraph: stop blanking and read every `<!--` as an
    # opener — abort-direction, since the sanctioned mention is a
    # same-line inline-code span in a paragraph with balanced runs.
    code_parity_suspect = False
    for line, fenced in _lines_with_fence_state(text):
        entered_commented = commented
        entered_inline = span_inline
        opens_comment = not fenced and _opens_comment(
            line, paragraph_open=paragraph_open
        )
        if not fenced:
            # A block opener only, list and blockquote markers included:
            # four columns STARTING a block makes indented code, and a fence
            # makes every marker inert. Not read as an opener HERE: a marker
            # mid-line, one in an inline-code span, or one indented as a lazy
            # paragraph continuation — inside the dissent span those are the
            # #613 inline state's job, now that the output grammar makes a
            # bare marker out-of-grammar prose. #613 tracks, and leaves
            # OPEN, the wider hiding channel this visibility model does not
            # cover at all: raw HTML that is not a comment, such as a
            # `<script>` or `<template>` block — the shipped closure is the
            # comment channel only.
            commented = _comment_state_after(
                line, commented=commented, paragraph_open=paragraph_open
            )
        if not fenced and (match := panel._H2_RE.fullmatch(line)):
            title = match.group(1)
            if inside and _is_dissent_field_shaped(title):
                span.append(title)
            else:
                inside = title == "Scoring Plan Dissent"
            paragraph_open = False
            span_inline = False
            code_parity_suspect = False
            continue
        # CommonMark counts only spaces and tabs as blank, so a line holding
        # an ideographic space is a paragraph. Calling it blank put the next
        # line at a block start and aborted a valid zh-TW card.
        expanded = line.expandtabs(4)
        state_dependent = (
            _SETEXT_UNDERLINE_RE if paragraph_open else _EMPTY_LIST_ITEM_RE
        )
        closes_paragraph = bool(
            _CLOSES_PARAGRAPH_RE.match(expanded)
            or state_dependent.match(expanded)
        )
        paragraph_open = (
            not fenced
            and bool(line.strip(" \t"))
            and not closes_paragraph
            # A recognized comment block is raw HTML, never a paragraph, so
            # the line after one is at a block start again. Recording its own
            # lines as an open paragraph read the next `2. <!--` with the
            # restricted pattern and credited the fields it hides.
            and not (entered_commented or opens_comment)
        )
        if inside:
            if not line.strip(" \t"):
                # A blank line closes the paragraph, and with it any
                # cross-line code-span ambiguity.
                code_parity_suspect = False
            opens_inline = False
            blanked = None
            if (not fenced and not entered_commented and not entered_inline
                    and not opens_comment):
                # #613: only lines the block model does NOT already own can
                # open the inline state; code spans are blanked first so the
                # grammar's sanctioned `` `<!--` `` mention stays prose —
                # unless this paragraph's runs stopped pairing locally, in
                # which case blanking is off and every marker opens.
                escaped = _ESCAPED_BACKTICK_RE.sub("  ", line)
                blanked = (
                    escaped if code_parity_suspect
                    else _blank_code_spans(line)
                )
                opens_inline = "<!--" in blanked
                if len(re.findall(r"`+", escaped)) % 2:
                    code_parity_suspect = True
            # #682: any non-comment raw-HTML tag/delimiter in the dissent
            # span is out of grammar even when it hides no field.  Scan the
            # display form after inline-code blanking; fenced examples retain
            # their previous semantics, and the exact H2 boundaries above
            # keep the rule span-scoped.  Under cross-line code ambiguity we
            # take the same abort-direction as the #613 comment guard rather
            # than letting a malformed tag earn a dissent exemption.
            if not fenced:
                html_scan = (
                    _ESCAPED_BACKTICK_RE.sub("  ", line)
                    if code_parity_suspect
                    else _blank_code_spans(line)
                )
                if _DISSENT_RAW_HTML_RE.search(html_scan):
                    raw_html.append(line)
            # Opened up only where a comment actually is. Rewriting every line
            # carrying the tokens would break a canonical `rationale:` that
            # merely mentions them in inline code from matching the
            # canonical parse, aborting an unretryable Phase 2 on a valid
            # card.
            if (entered_commented or opens_comment or entered_inline
                    or opens_inline):
                span.append(line.replace("<!--", " ").replace("-->", " "))
            else:
                span.append(line)
            if entered_commented or entered_inline:
                hidden_by_comment.append(line)
            if not fenced and (entered_inline or opens_inline):
                span_inline = _inline_comment_state_after(
                    blanked if blanked is not None
                    else _blank_code_spans(line),
                    commented=entered_inline,
                )
    return DissentSpan(span, hidden_by_comment, raw_html)


def _empty_dissent_section_diagnostic(raw_span: list[str]) -> str:
    """Counted on the raw span: fenced prose is archived content too."""
    non_blank = sum(1 for line in raw_span if line.strip())
    return (
        "[DISSENT-EMPTY-SECTION: ## Scoring Plan Dissent spells no dissent "
        "field; read as no dissent, with full Phase 1 trigger binding "
        f"enforced on every dimension; {non_blank} non-blank line(s) present "
        "— read the archived response if any narrate a deviation]"
    )


def _one_field(
    lines: list[str],
    field: str,
    path: str,
    *,
    required: bool,
    dimension_id: str,
) -> str | None:
    hits = [match.group("value") for line in lines
            if (match := _FIELD_PATTERNS[field].fullmatch(line))]
    expected = "exactly one" if required else "at most one"
    if (required and len(hits) != 1) or (not required and len(hits) > 1):
        raise ConformanceError(
            f"[PHASE1-GRAMMAR: {path}: expected {expected} canonical "
            f"{field}: line for dimension {dimension_id}, found {len(hits)}]"
        )
    return hits[0] if hits else None


def parse_phase1(
    path: str, text: str, contract: dict, role: str
) -> PhaseOnePlan:
    lines = panel.strip_fences(text)
    sections, dupes = panel.split_sections(lines)
    if "Scoring Plan" in dupes or "Scoring Plan" not in sections:
        raise ConformanceError(
            f"[PHASE1-GRAMMAR: {path}: exactly one ## Scoring Plan required]"
        )
    # §4 names three requirements, not one: the paraphrase section and the
    # terminal acknowledgement are as mandatory as the plan, and a plan
    # alone passing would let the dispatcher retry -- or accept -- a
    # protocol-invalid Phase 1.
    if "Contract Paraphrase" in dupes or "Contract Paraphrase" \
            not in sections:
        raise ConformanceError(
            f"[PHASE1-GRAMMAR: {path}: exactly one ## Contract Paraphrase "
            "required]"
        )
    # BOTH tails must be the marker. The raw tail catches output after
    # the acknowledgement (a trailing fenced block would vanish from the
    # structural view before the tail is computed); the fence-aware tail
    # catches an acknowledgement that exists only as fenced code.
    # Located by nonblankness but compared UNSTRIPPED (bar the line
    # ending): an indented `    [CONTRACT-ACKNOWLEDGED]` renders as a
    # code block, and stripping before comparison let it pass the exact
    # terminal-line requirement.
    raw_tail = next(
        (line for line in reversed(text.splitlines())
         if line.strip()), "")
    fenced_tail = next(
        (line for line in reversed(lines) if line.strip()), "")
    if raw_tail.rstrip() != "[CONTRACT-ACKNOWLEDGED]" or \
            fenced_tail.rstrip() != "[CONTRACT-ACKNOWLEDGED]":
        raise ConformanceError(
            f"[PHASE1-GRAMMAR: {path}: final nonblank line must be "
            "[CONTRACT-ACKNOWLEDGED]]"
        )
    # And in §4's exact order, with nothing else at H2: presence alone
    # would let a reordered or extra-sectioned precommitment pass. All
    # four real dispatch outputs carry exactly this sequence.
    h2_titles = [line[3:].strip() for line in lines
                 if line.startswith("## ")]
    if h2_titles != ["Contract Paraphrase", "Scoring Plan"]:
        raise ConformanceError(
            f"[PHASE1-GRAMMAR: {path}: H2 sections must be exactly "
            "## Contract Paraphrase then ## Scoring Plan, found "
            f"{h2_titles!r}]"
        )
    dimensions = {d["id"]: d for d in contract["acceptance_dimensions"]}
    # §4's paragraph floor: a bare heading over an empty or one-line body
    # is not the paraphrase the contract's `paraphrase_minimum_dimensions`
    # names ("all" = one paragraph per dimension). The count is the
    # machine-checkable lower bound; whether each paragraph is TIED to a
    # distinct dimension stays with the seat's own §4 preflight.
    # A CLOSED list of zero-content lines that separate and never count:
    # ATX headings, thematic breaks, single-line HTML comments -- six
    # bare `### Dn` headings (or six `---` rules) used to count as six
    # paragraphs, satisfying the floor with no paraphrase prose at all.
    # Deliberately NOT a full CommonMark block classifier: a list item
    # still counts, because a bulleted six-point paraphrase is real
    # content and refusing it would abort a panel over formatting (the
    # false-abort channel #609 exists to remove). Blocks are still
    # blank-line separated -- a TIGHT six-item list is one block and
    # does not meet a six-paragraph floor, same as before this list.
    # TERMINATION BOUND: zero-content variants beyond this list
    # (container-prefixed comments like `- <!-- -->`, malformed comments
    # like `<!-->`, entity/whitespace tricks) are out of scope by
    # declared design -- the variant space is unbounded, the observed
    # base rate in committed panels is zero, and §4's substantive
    # judgment sits with the seat's preflight, not this floor.
    separator = re.compile(
        r"#{1,6}(\s|$)"          # ATX heading
        r"|([-*_])(\s*\2){2,}$"  # thematic break
        r"|<!--.*-->$"           # single-line HTML comment
        r"|[-*+]$"               # lone list marker, no item text
    )
    paragraphs, in_paragraph, in_comment = 0, False, False
    for line in sections["Contract Paraphrase"]:
        stripped = line.strip()
        if in_comment:
            # Hidden until the closing `-->`, closer line included: six
            # multi-line comment blocks are as unrendered as six
            # single-line ones.
            if "-->" in stripped:
                in_comment = False
            in_paragraph = False
            continue
        if stripped.startswith("<!--") and "-->" not in stripped:
            # Conservative entry -- a line-LEADING opener with no closer
            # on the same line. Prose that merely mentions `<!--`
            # mid-line stays countable content.
            in_comment = True
            in_paragraph = False
            continue
        if stripped and not separator.match(stripped):
            if not in_paragraph:
                paragraphs += 1
                in_paragraph = True
        else:
            in_paragraph = False
    minimum = contract.get("measurement_procedure", {}).get(
        "paraphrase_minimum_dimensions")
    required = len(dimensions) if minimum == "all" else (
        minimum if isinstance(minimum, int) else 0)
    if paragraphs < required:
        raise ConformanceError(
            f"[PHASE1-GRAMMAR: {path}: Contract Paraphrase has "
            f"{paragraphs} paragraph(s), fewer than the {required} "
            "required]"
        )
    eligible = {
        did for did, dim in dimensions.items()
        if role in dim["eligible_roles"]
    }
    subsections, subsection_dupes = panel.split_subsections(
        sections["Scoring Plan"]
    )
    if subsection_dupes:
        raise ConformanceError(
            f"[PHASE1-GRAMMAR: {path}: duplicate scoring-plan subsection: "
            f"{', '.join(sorted(subsection_dupes))}]"
        )
    commitments: dict[str, dict[str, str]] = {}
    warnings: list[str] = []
    for title, sublines in subsections.items():
        match = panel._DIM_H3_RE.fullmatch(title)
        if not match or match.group("dim") not in dimensions:
            raise ConformanceError(
                f"[PHASE1-GRAMMAR: {path}: invalid subsection '### {title}']"
            )
        did = match.group("dim")
        if did not in eligible:
            raise ConformanceError(
                f"[PHASE1-OUT-OF-ROLE: {path}: role {role} planned {did}]"
            )
        if match.group("name") != dimensions[did]["name"]:
            raise ConformanceError(
                f"[PHASE1-GRAMMAR: {path}: {did} name mismatch]"
            )
        fields = {
            field: _one_field(
                sublines,
                field,
                path,
                required=True,
                dimension_id=did,
            )
            for field in (
                "dimension_id", "what_to_look_for",
                "what_triggers_block", "what_triggers_warn",
            )
        }
        mandatory = dimensions[did]["priority"] == "mandatory"
        fields["what_triggers_fatal"] = _one_field(
            sublines,
            "what_triggers_fatal",
            path,
            required=mandatory,
            dimension_id=did,
        )
        if not mandatory and fields["what_triggers_fatal"] is not None:
            raise ConformanceError(
                f"[PHASE1-GRAMMAR: {path}: what_triggers_fatal is forbidden "
                f"on non-mandatory dimension {did}]"
            )
        if fields["dimension_id"] != did:
            raise ConformanceError(
                f"[PHASE1-GRAMMAR: {path}: heading {did} disagrees with "
                f"dimension_id={fields['dimension_id']}]"
            )
        triggers = [
            fields["what_triggers_block"],
            fields["what_triggers_warn"],
        ]
        if mandatory:
            triggers.append(fields["what_triggers_fatal"])
        if len({_normalise(value) for value in triggers}) != len(triggers):
            raise ConformanceError(
                f"[PHASE1-TRIGGER-COLLISION: {path}: {did} trigger "
                "commitments must be pairwise distinct]"
            )
        for field in (
            "what_triggers_block", "what_triggers_warn",
            "what_triggers_fatal",
        ):
            value = fields[field]
            if value is not None and len(value.split()) < 8:
                warnings.append(
                    f"[PHASE1-TRIGGER-SHORT: {path}: {did} {field} "
                    "has fewer than 8 words]"
                )
        commitments[did] = fields
    if set(commitments) != eligible:
        raise ConformanceError(
            f"[PHASE1-SCOPE: {path}: planned={sorted(commitments)}, "
            f"eligible={sorted(eligible)}]"
        )
    return PhaseOnePlan(commitments, warnings)


def _flatten_metadata_values(value) -> list[str]:
    if isinstance(value, dict):
        return [
            item
            for nested in value.values()
            for item in _flatten_metadata_values(nested)
        ]
    if isinstance(value, list):
        return [
            item
            for nested in value
            for item in _flatten_metadata_values(nested)
        ]
    if isinstance(value, (str, int, float, bool)):
        return [str(value)]
    return []


def validate_metadata_envelope(metadata) -> None:
    if not isinstance(metadata, dict) or set(metadata) != _METADATA_KEYS:
        actual = (
            sorted(metadata)
            if isinstance(metadata, dict)
            else type(metadata).__name__
        )
        raise panel.ContractError(
            "[METADATA-INVALID: expected exact title/field/word_count "
            f"envelope, got {actual}]"
        )
    if (
        not isinstance(metadata["title"], str)
        or not metadata["title"].strip()
        or not isinstance(metadata["field"], str)
        or not metadata["field"].strip()
        or isinstance(metadata["word_count"], bool)
        or not isinstance(metadata["word_count"], int)
        or metadata["word_count"] < 0
    ):
        raise panel.ContractError(
            "[METADATA-INVALID: title and field must be non-empty strings; "
            "word_count must be a non-negative integer]"
        )


def check_manuscript_leakage(
    phase1_text: str, manuscript_text: str, metadata: dict, contract: dict
) -> None:
    validate_metadata_envelope(metadata)
    phase1_norm = _normalise(phase1_text)
    words = _normalise(manuscript_text).split()
    exemption_haystacks = [
        _normalise(value) for value in _flatten_metadata_values(metadata)
    ]
    exemption_haystacks.append(_normalise(json.dumps(
        contract, ensure_ascii=False, sort_keys=True
    )))
    for index in range(max(0, len(words) - 11)):
        shingle = " ".join(words[index:index + 12])
        if shingle not in phase1_norm:
            continue
        if any(shingle in haystack for haystack in exemption_haystacks):
            continue
        raise ConformanceError(
            "[PHASE1-MANUSCRIPT-LEAK: 12-word manuscript shingle appears "
            "in Phase 1 outside metadata/contract exemptions]"
        )


def parse_dissent_dimensions(text: str) -> DissentParse:
    lines = panel.strip_fences(text)
    sections, dupes = panel.split_sections(lines)
    if "Scoring Plan Dissent" in dupes:
        raise ConformanceError(
            "[DISSENT-GRAMMAR: duplicate ## Scoring Plan Dissent]"
        )
    if "Scoring Plan Dissent" not in sections:
        return DissentParse(set(), [])
    body = sections["Scoring Plan Dissent"]
    span = _raw_dissent_span(text)
    raw_span = span.lines
    # A commented-out field is not a claim the seat made, so it is struck from
    # the canonical parse and left to fail below as an unparsed occurrence.
    outstanding = Counter(span.hidden_by_comment)
    visible = []
    for line in body:
        if outstanding.get(line):
            outstanding[line] -= 1
            continue
        visible.append(line)
    parsed = Counter(
        line for line in visible
        if _DISSENT_DIM_RE.fullmatch(line)
        or _DISSENT_RATIONALE_RE.fullmatch(line)
    )
    dims = [match.group("dim") for line in visible
            if (match := _DISSENT_DIM_RE.fullmatch(line))]
    rationales = [
        match.group("text") for line in visible
        if (match := _DISSENT_RATIONALE_RE.fullmatch(line))
    ]
    # Scanned on the RAW span, not the sanitized body: a field the sanitizers
    # delete (fence, comment) or relocate (its own H2) would otherwise reach
    # the tolerance branch as an empty section. A field line the canonical
    # parse never saw is a dissent this seat cannot be credited with, so it
    # fails whether or not it is canonically spelled. Counted rather than
    # matched by value, so a hidden copy of a canonical field is still one
    # unparsed occurrence and cannot ride in on its twin's identity.
    hidden = Counter(
        candidate for candidate in raw_span
        if _is_dissent_field_shaped(candidate)
    )
    # Raw HTML owns its own diagnostic even when stripping the tag leaves a
    # field-shaped line.  Checking it first prevents a ``<span>dimension_id``
    # wrapper from being mislabeled as comment hiding by the older generic
    # raw-span occurrence guard.  Comment-only cards never populate this list
    # and retain the #613 ``[DISSENT-HIDDEN]`` path below.
    if span.raw_html:
        raise ConformanceError(
            "[DISSENT-RAW-HTML: raw HTML tags or delimiters are forbidden "
            "inside ## Scoring Plan Dissent; put markup mentions in inline "
            "code]"
        )
    if any(count > parsed[value] for value, count in hidden.items()):
        # Distinct marker (#613 security round 1, P3): these fields ARE
        # canonical — the failure is that comment markup hides them from
        # the rendered card, and pointing the operator at line grammar
        # misattributes an unretryable abort.
        raise ConformanceError(
            "[DISSENT-HIDDEN: a canonical dissent field is hidden from the "
            "rendered card by comment markup; write dissent fields in the "
            "clear and mention comment syntax only in inline code]"
        )
    if any(
        _is_dissent_field_shaped(candidate) and candidate not in parsed
        for candidate in visible
    ):
        raise ConformanceError(
            "[DISSENT-GRAMMAR: dissent fields must be canonical unbulleted "
            "dimension_id: and rationale: lines]"
        )
    if not dims and not rationales:
        # A section that spells no dissent field carries the same information
        # as an absent section, so it is read as no dissent instead of
        # aborting an unretryable Phase 2. The occurrence stays auditable in
        # the run record, and full Phase 1 trigger binding still applies to
        # every dimension.
        return DissentParse(
            set(), [_empty_dissent_section_diagnostic(raw_span)]
        )
    h2_positions = {
        match.group(1): index
        for index, line in enumerate(lines)
        if (match := panel._H2_RE.fullmatch(line))
    }
    if h2_positions["Scoring Plan Dissent"] > h2_positions.get(
        "Dimension Scores", -1
    ):
        raise ConformanceError(
            "[DISSENT-GRAMMAR: ## Scoring Plan Dissent must precede "
            "## Dimension Scores]"
        )
    if not dims:
        raise ConformanceError(
            "[DISSENT-GRAMMAR: dissent section must name dimension_id]"
        )
    if len(dims) != len(set(dims)):
        raise ConformanceError("[DISSENT-GRAMMAR: duplicate dimension_id]")
    if len(rationales) != len(dims):
        raise ConformanceError(
            "[DISSENT-GRAMMAR: each dissent requires one rationale: line]"
        )
    return DissentParse(set(dims), [])


def check_trigger_binding(
    report: panel.ReviewerReport,
    plan: PhaseOnePlan,
    dimensions: dict[str, dict],
    dissent: set[str],
) -> None:
    if len(dissent) >= 2:
        raise ConformanceError(
            f"[PROTOCOL-VIOLATION: multi_dissent=true, "
            f"dimensions={sorted(dissent)}]"
        )
    unknown = dissent - set(dimensions)
    if unknown:
        raise ConformanceError(
            f"[DISSENT-GRAMMAR: unknown dimensions {sorted(unknown)}]"
        )
    uncommitted = dissent - set(plan.commitments)
    if uncommitted:
        raise ConformanceError(
            f"[DISSENT-GRAMMAR: dissent dimensions were not committed by "
            f"this seat {sorted(uncommitted)}]"
        )
    for did, value in report.scores.items():
        eligible = report.role in dimensions[did]["eligible_roles"]
        needs_trigger = eligible and value.score in {"block", "warn"}
        if needs_trigger != bool(value.trigger):
            raise ConformanceError(
                f"[TRIGGER-GRAMMAR: {report.path}: {did} trigger is required "
                "iff an eligible dimension scores block or warn]"
            )
        if did in dissent:
            if value.block_class == "fatal":
                raise ConformanceError(
                    f"[DISSENT-FATALITY: {did} dissent may not mint fatality]"
                )
            continue
        if not value.trigger:
            continue
        if value.score == "warn":
            field = "what_triggers_warn"
        elif value.block_class == "fatal":
            field = "what_triggers_fatal"
        else:
            field = "what_triggers_block"
        committed = plan.commitments.get(did, {}).get(field)
        if not committed or _normalise(value.trigger) not in _normalise(committed):
            raise ConformanceError(
                f"[TRIGGER-DRIFT: {did} {field} does not contain emitted "
                "trigger text]"
            )
        matching_fields = {
            candidate
            for candidate in (
                "what_triggers_block", "what_triggers_warn",
                "what_triggers_fatal",
            )
            if plan.commitments.get(did, {}).get(candidate)
            and _normalise(value.trigger) in _normalise(
                plan.commitments[did][candidate]
            )
        }
        if matching_fields != {field}:
            raise ConformanceError(
                f"[TRIGGER-AMBIGUOUS: {did} emitted trigger matches "
                f"{sorted(matching_fields)}, expected only {field}]"
            )


def _validate_anchor(anchor: str, context: str) -> None:
    try:
        panel.validate_evidence_anchor(anchor, context)
    except panel.ReportError as exc:
        raise ConformanceError(str(exc)) from exc


def check_scoring_seat_anchors(report: panel.ReviewerReport) -> None:
    lines = panel.strip_fences(report.text)
    sections, dupes = panel.split_sections(lines)
    if "Review Body" in dupes or "Review Body" not in sections:
        raise ConformanceError(
            f"[REVIEW-BODY-MISSING: {report.path}]"
        )
    current_h2 = None
    for line in lines:
        if match := panel._H2_RE.fullmatch(line):
            current_h2 = match.group(1)
        elif _SEVERITY_DECL_RE.search(line) and current_h2 != "Review Body":
            raise ConformanceError(
                f"[FINDING-GRAMMAR: {report.path}: Severity outside "
                "## Review Body]"
            )
    review_lines = sections["Review Body"]
    blocks, subsection_dupes = panel.split_subsections(review_lines)
    if subsection_dupes:
        raise ConformanceError(
            f"[FINDING-GRAMMAR: {report.path}: duplicate finding heading]"
        )
    preamble = []
    for line in review_lines:
        if panel._H3_RE.fullmatch(line):
            break
        preamble.append(line)
    if any(_SEVERITY_DECL_RE.search(line) for line in preamble):
        raise ConformanceError(
            f"[FINDING-GRAMMAR: {report.path}: every finding with "
            "Severity must have its own ### finding heading]"
        )
    for title, block in blocks.items():
        severity_declarations = sum(
            len(_SEVERITY_DECL_RE.findall(line)) for line in block
        )
        severities = [
            match.group("severity") for line in block
            for match in _SEVERITY_RE.finditer(line)
        ]
        is_finding = _FINDING_H3_RE.fullmatch(title) is not None
        if severity_declarations and not is_finding:
            raise ConformanceError(
                f"[FINDING-GRAMMAR: {report.path}: every finding with "
                "Severity must have its own ### W<n>: <title> heading]"
            )
        if is_finding and any(panel._H4_RE.fullmatch(line) for line in block):
            raise ConformanceError(
                f"[FINDING-GRAMMAR: {report.path}: {title} may not nest "
                "a Severity finding under H4]"
            )
        if not is_finding:
            continue
        # A finding needs at least one parseable Severity declaration, and
        # every declaration must parse. When a card declares more than one
        # ACROSS lines and the chain strictly ESCALATES (Minor < Major <
        # Critical), the LAST in reading order is operative — the current
        # model generation self-corrects mid-card with explicit supersession
        # prose ("See the Severity line below, which supersedes the line
        # above", #637 ms01_quant r1: Major -> Critical), and Phase 2 permits
        # no retry for this class, so a strict exactly-one rule turns a
        # visible, reader-unambiguous correction into a whole-panel abort.
        # Every other multi-declaration shape keeps the loud abort:
        # de-escalation could waive the Critical/Major Evidence-Anchor
        # requirement by appending one weaker line; a non-monotone or
        # repeated-value chain signals several findings bundled under one W
        # heading (the one-finding-per-heading accounting feeds the severity
        # ladder); and two parseable declarations on ONE line are not a
        # reading-order correction at all. The advisory line below keeps the
        # full declaration trail in the gate log for adjudication.
        parseable_per_line = [
            sum(1 for _ in _SEVERITY_RE.finditer(line)) for line in block
        ]
        if (not severities or len(severities) != severity_declarations
                or any(count > 1 for count in parseable_per_line)):
            raise ConformanceError(
                f"[FINDING-GRAMMAR: {report.path}: {title} must contain "
                "exactly one parseable Severity declaration]"
            )
        severity_rank = {"Minor": 0, "Major": 1, "Critical": 2}
        if any(severity_rank[later] <= severity_rank[earlier]
               for earlier, later in zip(severities, severities[1:])):
            raise ConformanceError(
                f"[FINDING-GRAMMAR: {report.path}: {title}: multiple "
                "Severity declarations must form a strictly escalating "
                "self-correction chain]"
            )
        if len(severities) > 1:
            print(
                f"[SEVERITY-SUPERSEDED: {report.path}: {title}: "
                + " -> ".join(severities) + "]"
            )
        operative_severity = severities[-1]
        anchor_declarations = sum(
            len(_ANCHOR_DECL_RE.findall(line)) for line in block
        )
        anchors = [
            match.group("value") for line in block
            for match in _ANCHOR_RE.finditer(line)
        ]
        if operative_severity not in {"Critical", "Major"}:
            if anchor_declarations > 1 or len(anchors) != anchor_declarations:
                raise ConformanceError(
                    f"[FINDING-GRAMMAR: {report.path}: {title} may contain "
                    "at most one parseable Evidence Anchor declaration]"
                )
            if anchors:
                _validate_anchor(anchors[0], f"{report.path}:{title}")
            continue
        if len(anchors) != 1 or anchor_declarations != 1:
            raise ConformanceError(
                f"[ANCHOR-MISSING: {report.path}: {title} "
                f"{operative_severity} finding needs exactly one "
                "Evidence Anchor]"
            )
        _validate_anchor(anchors[0], f"{report.path}:{title}")


def check_da_anchors(report: panel.ReviewerReport) -> None:
    try:
        rows, major_anchors = panel.parse_da_tables(report.text, report.path)
    except panel.ReportError as exc:
        raise ConformanceError(str(exc)) from exc
    expected = [f"C{index}" for index in range(1, len(rows) + 1)]
    if list(rows) != expected:
        raise ConformanceError(
            f"[DA-CRITICAL-ID: {report.path}: IDs must be dense C1..Cn; "
            f"got={list(rows)}]"
        )
    for finding_id, anchor in rows.items():
        if not anchor:
            raise ConformanceError(
                f"[ANCHOR-MISSING: {report.path}: {finding_id}]"
            )
        _validate_anchor(anchor, f"{report.path}:{finding_id}")

    for anchor in major_anchors:
        if not anchor:
            raise ConformanceError(
                f"[ANCHOR-MISSING: {report.path}: DA MAJOR row]"
            )
        _validate_anchor(anchor, f"{report.path}:DA MAJOR")


def _one_receipt_field(
    lines: list[str], key: str, path: str, receipt_id: str, *, required: bool
) -> str | None:
    hits = [
        match.group("value")
        for line in lines
        if (match := _RECEIPT_FIELD_RES[key].fullmatch(line))
    ]
    expected = "exactly one" if required else "at most one"
    if (required and len(hits) != 1) or (not required and len(hits) > 1):
        raise ConformanceError(
            f"[RECEIPT-GRAMMAR: {path}: {receipt_id} expected {expected} "
            f"canonical {key}: line, found {len(hits)}]"
        )
    return hits[0] if hits else None


def _review_body_receipt_backrefs(
    report: panel.ReviewerReport,
) -> tuple[set[str], dict[str, list[str]]]:
    """W-finding ids and per-block `**Arithmetic Receipt**:` back-references.

    Back-references are collected across the WHOLE Review Body — preamble and
    non-W subsections included — so a back-reference stranded outside its
    weakness block is a linkage failure, not invisible. The walk is
    fence-aware: only unfenced headings delimit (agreeing with
    `split_sections`), a fenced or decorated back-reference declaration is
    counted by the lenient detector, and a declaration count exceeding the
    canonical parse aborts — a back-reference the seat spelled but the
    grammar refused is a linkage failure, never a silent drop.
    """
    lines = panel.strip_fences(report.text)
    sections, _ = panel.split_sections(lines)
    review_lines = sections.get("Review Body", [])
    blocks, _ = panel.split_subsections(review_lines)
    finding_ids = {
        title.split(":", 1)[0]
        for title in blocks
        if _FINDING_H3_RE.fullmatch(title)
    }
    backrefs: dict[str, list[str]] = {}
    current = "(preamble)"
    inside = False
    inline_commented = False
    for line, fenced, hidden, code_indented in _lines_with_hidden_state(
        report.text
    ):
        if not fenced and (match := panel._H2_RE.fullmatch(line)):
            inside = match.group(1) == "Review Body"
            current = "(preamble)"
            inline_commented = False
            continue
        if not inside:
            continue
        parse_line = line
        if not fenced and not hidden and not code_indented:
            # A paragraph-inline comment span cannot cross a paragraph
            # boundary: a blank line or an interrupting ATX heading (any
            # level) ends the paragraph and with it the raw-HTML span, so
            # the state resets there instead of leaking a false abort into
            # later prose. Code spans are blanked first, matching the
            # renderer's precedence: a literal `<!--` inside inline code
            # opens nothing (#610 round-4).
            if (
                not line.strip(" \t")
                or _ATX_HEADING_RE.match(line)
            ):
                inline_commented = False
            else:
                code_blanked = _blank_code_spans(line)
                visible, hidden_segments, inline_commented = (
                    _strip_inline_comment_spans(
                        code_blanked, inline_commented
                    )
                )
                if visible != code_blanked:
                    # A declaration inside a hidden span aborts whether or
                    # not the line also shows visible content (#610 round
                    # 5): hidden prose is skippable, a hidden machine
                    # declaration never is. Each span is checked on its
                    # own (#610 round-6).
                    if any(
                        _backref_declared_count(segment)
                        for segment in hidden_segments
                    ):
                        raise ConformanceError(
                            f"[RECEIPT-LINKAGE: {report.path}: an "
                            "Arithmetic Receipt back-reference "
                            "declaration sits inside a paragraph-"
                            "inline HTML comment span and does not "
                            "render; it is non-conforming]"
                        )
                    if not visible.strip(" \t"):
                        continue
                    # Only the rendered remainder is parsed: content after
                    # a closing `-->` stays live, content behind an opener
                    # is gone.
                    parse_line = visible
        if fenced or hidden or code_indented:
            # Never credited: a machine declaration the page does not show
            # as a field line — fenced, commented, or rendered as indented
            # code — is a loud failure, not a silent drop or a silent
            # credit (#610 rounds 2-3).
            if _backref_declared_count(line):
                kind = (
                    "fenced" if fenced
                    else "commented-out" if hidden
                    else "indented-code"
                )
                raise ConformanceError(
                    f"[RECEIPT-LINKAGE: {report.path}: a {kind} Arithmetic "
                    "Receipt back-reference declaration does not render as "
                    "a field line and is non-conforming]"
                )
            continue
        if match := panel._H3_RE.fullmatch(line):
            title = match.group(1)
            current = (
                title.split(":", 1)[0]
                if _FINDING_H3_RE.fullmatch(title)
                else f"(non-finding: {title})"
            )
            continue
        # Canonical parsing and the declaration count run on the SAME
        # display form (#610 round-4 P1): parsing the raw line while
        # counting on a blanked one let a code-span declaration be
        # credited over the rendered field beside it.
        display = _cell_split_form(parse_line)
        matches = list(_RECEIPT_BACKREF_RE.finditer(display))
        if _backref_declared_count(display) != len(matches):
            raise ConformanceError(
                f"[RECEIPT-LINKAGE: {report.path}: back-reference "
                f"declaration(s) on {line.strip()!r} do not all parse "
                "canonically — each value must be exactly "
                "**Arithmetic Receipt**: AR<n> with no trailing text]"
            )
        for match in matches:
            backrefs.setdefault(current, []).append(match.group("value"))
    return finding_ids, backrefs


_INDENTED_H2_RE = re.compile(r"^ {1,3}##\s+\S")
# Any ATX heading interrupts a paragraph (CommonMark), so any level ends a
# paragraph-inline comment span — resetting only on H3 false-aborted a
# rendered backref after an interrupting H4 (#610 round-4).
_ATX_HEADING_RE = re.compile(r"^ {0,3}#{1,6}(?:[ \t]|$)")


def _receipt_section_view(
    text: str,
) -> tuple[list[tuple[str, bool]], list[str], bool]:
    """Receipt-section lines with visibility, the unfenced H2 order, and
    whether an indented H2 renders after the section opened.

    The section body is read through `_lines_with_hidden_state` rather than
    `strip_fences` (#610 rounds 1-2, the #637/#609 convergence): a model
    that fences its receipt block still WROTE the receipts, so the fenced
    lines are read as content — no false abort — while a fenced `### AR<n>`
    block sitting beside an unfenced attestation is SEEN and aborts as
    receipts-plus-attestation instead of hiding. Each content line carries
    its hidden flag so a machine line inside an HTML comment — which the
    rendered card does not show — can abort rather than be credited. Only
    an unfenced H2 delimits, agreeing with `split_sections` (a COMMENTED
    heading therefore still delimits, as in `_raw_dissent_span`), so a
    fenced heading can neither open nor close the section. The H2 title is
    matched exactly, case-sensitively, consistent with every other section
    grammar. A 1-3-space-indented `##` line is not a section to this
    grammar but still renders as a heading, so one appearing after the
    receipt section opens is reported for the terminal-section rule.
    """
    h2_titles: list[str] = []
    section: list[tuple[str, bool, bool]] = []
    inside = False
    indented_h2_after = False
    for line, fenced, hidden, _ in _lines_with_hidden_state(text):
        if not fenced and (match := panel._H2_RE.fullmatch(line)):
            h2_titles.append(match.group(1))
            inside = match.group(1) == _RECEIPT_SECTION
            continue
        if inside:
            if not fenced and not hidden and _INDENTED_H2_RE.match(line):
                indented_h2_after = True
            section.append((line, hidden, fenced))
    return section, h2_titles, indented_h2_after


def check_methodology_receipts(report: panel.ReviewerReport) -> None:
    """#610 arithmetic-receipt gate, methodology seat only.

    Auditability, not truth: this gate proves the receipt fields exist, use
    the closed enums, and link mismatches to weaknesses bidirectionally. It
    never attests that the arithmetic is correct — that judgment stays with
    human adjudication (`VERIFIED` / `MISCOMPUTED`), per the spec's invariant
    6 and the receipt block's leading epistemic-status note.
    """
    view, h2_titles, indented_h2_after = _receipt_section_view(report.text)
    occurrences = h2_titles.count(_RECEIPT_SECTION)
    if occurrences > 1:
        raise ConformanceError(
            f"[RECEIPT-GRAMMAR: {report.path}: duplicate "
            f"## {_RECEIPT_SECTION}]"
        )
    if occurrences == 0:
        raise ConformanceError(
            f"[RECEIPT-MISSING: {report.path}: methodology card requires "
            f"exactly one ## {_RECEIPT_SECTION} section]"
        )
    if h2_titles[-1] != _RECEIPT_SECTION or indented_h2_after:
        raise ConformanceError(
            f"[RECEIPT-GRAMMAR: {report.path}: ## {_RECEIPT_SECTION} must "
            "be the final section of the card]"
        )
    in_subsection = False
    for line, hidden, fenced in view:
        if not fenced and ("<!--" in line or "-->" in line):
            # Comment-free zone (#610 round-3 P1): the receipt section is
            # machine lines, so a paragraph-inline `prose <!--` opener —
            # which the block-position visibility model deliberately does
            # not read — could otherwise launder the receipts below it out
            # of the rendered card. Banning the markup outright is
            # deterministic and costs no legitimate content; fenced lines
            # render the markup literally and stay exempt.
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: HTML comment markup "
                f"{line.strip()!r} is not allowed in the receipt section]"
            )
        if panel._H3_RE.fullmatch(line):
            if hidden:
                raise ConformanceError(
                    f"[RECEIPT-GRAMMAR: {report.path}: receipt heading "
                    f"{line.strip()!r} is inside an HTML comment; the "
                    "rendered card does not show it]"
                )
            in_subsection = True
            continue
        canonical = bool(
            _RECEIPT_ATTESTATION_RE.fullmatch(line)
            or any(
                pattern.fullmatch(line)
                for pattern in _RECEIPT_FIELD_RES.values()
            )
        )
        if canonical:
            if hidden:
                raise ConformanceError(
                    f"[RECEIPT-GRAMMAR: {report.path}: receipt machine "
                    f"line {line.strip()!r} is inside an HTML comment; the "
                    "rendered card does not show it]"
                )
            if (
                not in_subsection
                and not _RECEIPT_ATTESTATION_RE.fullmatch(line)
            ):
                raise ConformanceError(
                    f"[RECEIPT-GRAMMAR: {report.path}: receipt machine "
                    f"line {line.strip()!r} sits outside every ### AR<n> "
                    "subsection; the enum and linkage gates never inspect "
                    "it there]"
                )
            continue
        if any(
            _is_receipt_field_shaped(candidate)
            for candidate in _receipt_shape_candidates(line)
        ):
            # One neutral message for both visibility states: an opener
            # line like `<!-- c --> key: value` is hidden to the model but
            # partially renders, so claiming "commented-out" would misread
            # the page to the seat (#610 round-3 P3).
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: receipt machine line "
                f"{line.strip()!r} is decorated or non-canonical; write "
                "plain unbulleted key: value text (tolerated: one "
                "leading list marker, balanced bold around the key)]"
            )
    body = [line for line, _, _ in view]
    attestations = [
        line for line in body if _RECEIPT_ATTESTATION_RE.fullmatch(line)
    ]
    subsections, sub_dupes = panel.split_subsections(body)
    if sub_dupes:
        raise ConformanceError(
            f"[RECEIPT-GRAMMAR: {report.path}: duplicate receipt heading(s) "
            f"{sorted(sub_dupes)}]"
        )
    for title in subsections:
        if not _RECEIPT_H3_RE.fullmatch(title):
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: invalid receipt "
                f"subsection '### {title}'; expected ### AR<n>]"
            )
    if not subsections:
        if len(attestations) != 1:
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: a receipt section with "
                "no ### AR<n> subsection requires exactly one "
                f"no_recomputable_statistics: line, found {len(attestations)}]"
            )
        # Honest-claim boundary (#610 round-1 fix 2): the gate proved only
        # that the declaration EXISTS. Whether the manuscript really has
        # nothing recomputable is judged at adjudication, so the pass is
        # annotated rather than silent.
        print(_RECEIPT_ATTESTATION_ADVISORY)
        return
    if attestations:
        raise ConformanceError(
            f"[RECEIPT-GRAMMAR: {report.path}: no_recomputable_statistics: "
            "is forbidden when ### AR<n> receipts exist]"
        )
    expected_ids = [f"AR{index}" for index in range(1, len(subsections) + 1)]
    if list(subsections) != expected_ids:
        raise ConformanceError(
            f"[RECEIPT-GRAMMAR: {report.path}: receipt IDs must be dense "
            f"AR1..ARn in order; got={list(subsections)}]"
        )
    finding_ids, backrefs = _review_body_receipt_backrefs(report)
    mismatch_refs: dict[str, str] = {}
    for receipt_id, sublines in subsections.items():
        procedure = _one_receipt_field(
            sublines, "procedure_id", report.path, receipt_id, required=True
        )
        if procedure not in _RECEIPT_PROCEDURES:
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: {receipt_id} "
                f"procedure_id '{procedure}' is not a bounded procedure]"
            )
        anchor = _one_receipt_field(
            sublines, "evidence_anchor", report.path, receipt_id,
            required=True,
        )
        _validate_anchor(anchor, f"{report.path}:{receipt_id}")
        for key in (
            "reported_inputs", "assumptions", "derivation",
            "comparison_rule",
        ):
            _one_receipt_field(
                sublines, key, report.path, receipt_id, required=True
            )
        derived = _one_receipt_field(
            sublines, "derived_value_or_range", report.path, receipt_id,
            required=True,
        )
        status = _one_receipt_field(
            sublines, "status", report.path, receipt_id, required=True
        )
        if status not in _RECEIPT_STATUSES:
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: {receipt_id} status "
                f"'{status}' is not in the closed status enum]"
            )
        reason = _one_receipt_field(
            sublines, "not_computable_reason", report.path, receipt_id,
            required=(status == "not_computable"),
        )
        if status != "not_computable" and reason is not None:
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: {receipt_id} "
                "not_computable_reason is forbidden unless status is "
                "not_computable]"
            )
        if reason is not None and reason not in _NOT_COMPUTABLE_REASONS:
            raise ConformanceError(
                f"[RECEIPT-GRAMMAR: {report.path}: {receipt_id} "
                f"not_computable_reason '{reason}' is not in the closed v1 "
                "enum]"
            )
        tail = None
        for key, procedures in _PROCEDURE_FIELD_OWNERS.items():
            if procedure in procedures:
                required = (
                    key in _ALWAYS_REQUIRED_PROCEDURE_FIELDS
                    or status in _RECEIPT_VERDICT_STATUSES
                )
                value = _one_receipt_field(
                    sublines, key, report.path, receipt_id, required=required
                )
                if key == "tail_convention":
                    tail = value
            else:
                if _one_receipt_field(
                    sublines, key, report.path, receipt_id, required=False
                ) is not None:
                    raise ConformanceError(
                        f"[RECEIPT-GRAMMAR: {report.path}: {receipt_id} "
                        f"{key} is forbidden for procedure {procedure}]"
                    )
        if procedure == "p_from_test_statistic":
            if tail is not None and tail not in _TAIL_CONVENTIONS:
                raise ConformanceError(
                    f"[RECEIPT-GRAMMAR: {report.path}: {receipt_id} "
                    f"tail_convention '{tail}' is not in the closed enum]"
                )
            if tail == "unstated" and status in _RECEIPT_VERDICT_STATUSES:
                derived_fold = unicodedata.normalize(
                    "NFKC", derived
                ).casefold()
                if not all(
                    _tail_value_shown(derived_fold, label_re)
                    for label_re in _TAIL_LABEL_RES.values()
                ):
                    raise ConformanceError(
                        f"[RECEIPT-TAILS: {report.path}: {receipt_id} "
                        "unstated tail requires derived_value_or_range to "
                        "show BOTH labeled VALUES — each of the two-tailed "
                        "and one-tailed labels sharing its own ;-segment "
                        "with its derived number, either order]"
                    )
        finding_ref = _one_receipt_field(
            sublines, "finding_ref", report.path, receipt_id,
            required=(status == "mismatch"),
        )
        if status != "mismatch":
            if finding_ref is not None:
                raise ConformanceError(
                    f"[RECEIPT-LINKAGE: {report.path}: {receipt_id} "
                    "finding_ref is forbidden unless status is mismatch]"
                )
            continue
        if not _FINDING_REF_VALUE_RE.fullmatch(finding_ref):
            raise ConformanceError(
                f"[RECEIPT-LINKAGE: {report.path}: {receipt_id} finding_ref "
                f"'{finding_ref}' must name one W<n> weakness]"
            )
        if finding_ref not in finding_ids:
            raise ConformanceError(
                f"[RECEIPT-LINKAGE: {report.path}: {receipt_id} finding_ref "
                f"{finding_ref} has no matching ### {finding_ref} weakness "
                "in ## Review Body]"
            )
        if finding_ref in mismatch_refs:
            raise ConformanceError(
                f"[RECEIPT-LINKAGE: {report.path}: {finding_ref} is claimed "
                f"by both {mismatch_refs[finding_ref]} and {receipt_id}; "
                "no two receipts share a finding_ref]"
            )
        mismatch_refs[finding_ref] = receipt_id
    for finding_id, receipt_id in mismatch_refs.items():
        if backrefs.get(finding_id) != [receipt_id]:
            raise ConformanceError(
                f"[RECEIPT-LINKAGE: {report.path}: weakness {finding_id} "
                "must carry exactly one **Arithmetic Receipt**: "
                f"{receipt_id} back-reference, found "
                f"{backrefs.get(finding_id, [])}]"
            )
    for location, values in backrefs.items():
        for value in values:
            if mismatch_refs.get(location) != value:
                raise ConformanceError(
                    f"[RECEIPT-LINKAGE: {report.path}: back-reference "
                    f"{value} in {location} does not correspond to a "
                    "mismatch receipt naming that weakness]"
                )


def check_recompute_extraction(path: str, text: str) -> None:
    """#610 step-5 extraction gate, methodology seat only.

    The isolated numeric input surface: the response must be exactly one
    ``## Recompute Extraction`` section of machine lines. The grammar
    authority is the calculator's own parser (`recompute_receipts`), so the
    gate and the consumer can never disagree about what an extraction says;
    this gate adds the response-level structure rules and the anchor-grammar
    check the calculator deliberately does not own.
    """
    lines = panel.strip_fences(text)
    sections, dupes = panel.split_sections(lines)
    if recompute.EXTRACTION_SECTION in dupes:
        raise ConformanceError(
            f"[EXTRACTION-GRAMMAR: {path}: duplicate "
            f"## {recompute.EXTRACTION_SECTION}]"
        )
    if recompute.EXTRACTION_SECTION not in sections:
        raise ConformanceError(
            f"[EXTRACTION-GRAMMAR: {path}: exactly one "
            f"## {recompute.EXTRACTION_SECTION} section is required]"
        )
    extra = [
        title for title in list(sections) + list(dupes)
        if title != recompute.EXTRACTION_SECTION
    ]
    if extra:
        raise ConformanceError(
            f"[EXTRACTION-GRAMMAR: {path}: the response may carry no "
            f"section other than ## {recompute.EXTRACTION_SECTION}; "
            f"found {extra}]"
        )
    preamble = []
    for line in lines:
        if panel._H2_RE.fullmatch(line):
            break
        preamble.append(line)
    if any(line.strip() for line in preamble):
        raise ConformanceError(
            f"[EXTRACTION-GRAMMAR: {path}: no content is allowed before "
            f"## {recompute.EXTRACTION_SECTION}]"
        )
    try:
        extraction = recompute.parse_extraction(text)
    except recompute.ExtractionError as exc:
        raise ConformanceError(
            f"[EXTRACTION-GRAMMAR: {path}: {exc}]"
        ) from exc
    for request in extraction.requests:
        _validate_anchor(
            request["evidence_anchor"], f"{path}:{request.rr_id}"
        )
    if extraction.attestation is not None:
        # Same declaration-only honesty boundary as the receipt attestation.
        print(_RECEIPT_ATTESTATION_ADVISORY)


def check_injected_receipts(
    report: panel.ReviewerReport, injected_text: str
) -> None:
    """#610 step-5 identity gate: the card's receipt section must be the
    dispatcher-injected receipts verbatim, plus only the canonical
    ``finding_ref:`` lines the mismatch receipts require.

    Runs AFTER `check_methodology_receipts`, so grammar, enum, linkage, and
    per-subsection `finding_ref` placement are already proven; this gate
    proves nothing else changed. The comparison ignores blank lines and
    reads the card fence-transparently — the same view the receipt gate
    uses — so a decorated or re-spelled injected line fails identity loudly
    rather than being silently re-read.
    """
    injected_lines = [
        line.rstrip("\r") for line in injected_text.split("\n")
    ]
    heading = f"## {recompute.RECEIPT_SECTION}"
    if not injected_lines or injected_lines[0] != heading:
        raise panel.ContractError(
            f"[INJECTED-RECEIPTS-INVALID: the injected file must begin "
            f"with {heading!r}]"
        )
    expected = [line for line in injected_lines[1:] if line.strip()]
    view, _, _ = _receipt_section_view(report.text)
    # Only the PLAIN spelling is the permitted addition (codex round 1,
    # P2-4): the receipt grammar tolerates a decorated finding_ref, but
    # under injection "add exactly one finding_ref: line" means the
    # undecorated canonical form — a bolded or bulleted spelling stays in
    # the comparison and fails identity loudly.
    plain_finding_ref = re.compile(r"^finding_ref: W[1-9]\d*$")
    actual = [
        line for line, _, _ in view
        if line.strip() and not plain_finding_ref.fullmatch(line)
    ]
    if actual != expected:
        divergence = next(
            (
                f"card={card!r} vs injected={wanted!r}"
                for card, wanted in zip(actual, expected)
                if card != wanted
            ),
            f"card has {len(actual)} content lines, injected has "
            f"{len(expected)}",
        )
        raise ConformanceError(
            f"[RECEIPT-IDENTITY: {report.path}: the ## "
            f"{recompute.RECEIPT_SECTION} section must reproduce the "
            "dispatcher-computed receipts verbatim, adding only "
            f"finding_ref: lines on mismatch receipts; first divergence: "
            f"{divergence}]"
        )


def check_receipt_section_forbidden(report: panel.ReviewerReport) -> None:
    # Declared boundary: this guard sees what `split_sections` sees, so a
    # fenced or indented `## Arithmetic Receipts` on a non-methodology seat
    # is an inert displayed block, not a section — it earns the seat
    # nothing (no consumer reads it) and is deliberately not chased here.
    lines = panel.strip_fences(report.text)
    sections, dupes = panel.split_sections(lines)
    if _RECEIPT_SECTION in sections or _RECEIPT_SECTION in dupes:
        raise ConformanceError(
            f"[RECEIPT-SECTION-FORBIDDEN: {report.path}: role "
            f"{report.role} may not emit ## {_RECEIPT_SECTION}; the #610 "
            "receipt gate is methodology-only]"
        )


def _parse_args(argv):
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--contract", required=True, type=Path)
    parser.add_argument("--role", required=True)
    parser.add_argument("--phase1", required=True, type=Path)
    # The retry decision is taken while Phase 2 has not been requested yet, so
    # the gate has to be answerable on Phase 1 alone. Mirrors the
    # --synthesis / --layer1-only split in check_panel_synthesis.py.
    stage = parser.add_mutually_exclusive_group(required=True)
    stage.add_argument("--phase2", type=Path)
    stage.add_argument("--phase1-only", action="store_true")
    # #610 step 5: the methodology extraction call is its own gated stage,
    # answerable between Phase 1 and Phase 2 like --phase1-only is before
    # Phase 2.
    stage.add_argument("--extraction", type=Path)
    parser.add_argument("--injected-receipts", type=Path)
    parser.add_argument("--manuscript", required=True, type=Path)
    parser.add_argument("--metadata", required=True, type=Path)
    args = parser.parse_args(argv)
    if args.injected_receipts is not None and args.phase2 is None:
        parser.error("--injected-receipts requires --phase2")
    return args


def main(argv=None) -> int:
    args = _parse_args(argv)
    try:
        contract, _ = panel.load_contract(args.contract)
        if args.role not in panel.ROLE_SETS[contract["mode"]]:
            raise panel.ContractError(
                f"[ROLE-BINDING: --role {args.role} is invalid for "
                f"{contract['mode']}]"
            )
        phase1_text = panel._read_text(args.phase1)
        phase2_text = (
            panel._read_text(args.phase2) if args.phase2 is not None
            else None
        )
        manuscript_text = panel._read_text(args.manuscript)
        try:
            metadata = json.loads(panel._read_text(args.metadata))
        except json.JSONDecodeError as exc:
            raise panel.ContractError(
                f"[METADATA-INVALID: {args.metadata}: {exc}]"
            ) from exc
        if args.phase1_only:
            # Blindness FIRST, before structural parsing: a response both
            # malformed and leaking would otherwise report only the grammar
            # failure, and the dispatcher would grant the retry a proven
            # leak must never receive. It is the half a retry must not be
            # granted in spite of.
            check_manuscript_leakage(
                phase1_text, manuscript_text, metadata, contract
            )
        plan = parse_phase1(str(args.phase1), phase1_text, contract, args.role)
        for warning in plan.warnings:
            print(warning)
        if args.phase1_only:
            print("PHASE1-CONFORMANCE: PASS")
            return EXIT_PASS
        if args.extraction is not None:
            # #610 step 5. The extraction call is methodology-only by
            # design: no other seat has an extraction stage to gate.
            if args.role != "methodology":
                raise panel.ContractError(
                    f"[ROLE-BINDING: --extraction is methodology-only, "
                    f"dispatched as {args.role}]"
                )
            check_manuscript_leakage(
                phase1_text, manuscript_text, metadata, contract
            )
            check_recompute_extraction(
                str(args.extraction), panel._read_text(args.extraction)
            )
            print("EXTRACTION-CONFORMANCE: PASS")
            return EXIT_PASS
        report = panel.parse_report(
            str(args.phase2), phase2_text, contract
        )
        if report.role != args.role:
            raise ConformanceError(
                f"[ROLE-BINDING: report declares {report.role}, dispatched "
                f"as {args.role}]"
            )
        check_manuscript_leakage(
            phase1_text, manuscript_text, metadata, contract
        )
        dissent = parse_dissent_dimensions(phase2_text)
        for diagnostic in dissent.diagnostics:
            print(diagnostic)
        dimensions = {
            dim["id"]: dim for dim in contract["acceptance_dimensions"]
        }
        check_trigger_binding(report, plan, dimensions, dissent.dimensions)
        if report.role == "da":
            check_da_anchors(report)
        else:
            check_scoring_seat_anchors(report)
        if report.role == "methodology":
            check_methodology_receipts(report)
            if args.injected_receipts is not None:
                check_injected_receipts(
                    report, panel._read_text(args.injected_receipts)
                )
                # A distinct witness line (security round 1, P2-5): the
                # evidence contract names this gate as contract content, so
                # a Phase 2 gated WITHOUT it must be distinguishable in the
                # preserved gate log.
                print("RECEIPT-IDENTITY: PASS")
        else:
            if args.injected_receipts is not None:
                raise panel.ContractError(
                    f"[ROLE-BINDING: --injected-receipts is "
                    f"methodology-only, dispatched as {args.role}]"
                )
            check_receipt_section_forbidden(report)
    except panel.ContractError as exc:
        print(exc)
        return EXIT_CONTRACT
    except (panel.ReportError, ConformanceError) as exc:
        print(exc)
        return EXIT_CONFORMANCE
    print("PHASE-CONFORMANCE: PASS")
    return EXIT_PASS


if __name__ == "__main__":
    sys.exit(main())