Paper Orchestra

#!/usr/bin/env python3
"""
anti_leakage_check.py — Deterministic post-hoc check that the LLM obeyed the
Universal Anti-Leakage Prompt (arXiv:2604.05018, App. D.4).

Greps a generated LaTeX paper for forbidden artifacts:

  - Email addresses (a-z0-9.+_-@a-z0-9.-)
  - "corresponding author" / "Correspondence to" phrases
  - Common affiliation tokens (Google, OpenAI, Microsoft, DeepMind, FAIR, etc.)
  - Author-list patterns (e.g., "FirstName LastName, FirstName LastName, ...")
    in the title-block region (before \\begin{document} or first \\section)

Exit codes:
    0  no leaks found
    1  leaks found (the orchestrator should reject the draft and re-prompt)

This is a safety net, NOT a substitute for the prompt itself.

Usage:
    python anti_leakage_check.py path/to/paper.tex
"""
import re
import sys

EMAIL_RE = re.compile(r"[a-zA-Z0-9_.+\-]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-.]+")
CORR_AUTHOR_RE = re.compile(r"corresponding\s+author|correspondence\s+to", re.I)

# Affiliation tokens that appear in real papers' title blocks. These are
# heuristics; false positives are possible if a paper legitimately discusses
# one of these as a topic. The check fires only on the title-block region.
AFFILIATION_TOKENS = [
    "Google", "OpenAI", "Microsoft", "DeepMind", "Meta AI", "FAIR",
    "Anthropic", "Stanford", "MIT", "Berkeley", "CMU",
    "Tsinghua", "Peking University", "Cornell",
]

# An author-list pattern: "Name1, Name2, Name3 and Name4" or with superscripts.
AUTHOR_LIST_RE = re.compile(
    r"(?:[A-Z][a-z]+\s+[A-Z][a-z]+(?:\s*\^\d+|\s*\$\^\{\d+\}\$)?(?:\s*,\s*|\s+and\s+)){2,}"
    r"[A-Z][a-z]+\s+[A-Z][a-z]+"
)


def get_titleblock(text: str) -> str:
    """Return the region between \\begin{document} (or top) and the first \\section."""
    start_m = re.search(r"\\begin\{document\}", text)
    start = start_m.end() if start_m else 0
    end_m = re.search(r"\\section\b", text[start:])
    end = start + end_m.start() if end_m else min(start + 4000, len(text))
    return text[start:end]


def check(path: str) -> int:
    text = open(path).read()
    leaks: list[str] = []

    for m in EMAIL_RE.finditer(text):
        leaks.append(f"  email: {m.group()}")

    for m in CORR_AUTHOR_RE.finditer(text):
        ctx = text[max(0, m.start()-30):m.end()+30].replace("\n", " ")
        leaks.append(f"  corresponding-author phrase: ...{ctx}...")

    titleblock = get_titleblock(text)
    for tok in AFFILIATION_TOKENS:
        if re.search(rf"\b{re.escape(tok)}\b", titleblock):
            leaks.append(f"  affiliation token in title block: {tok}")

    m = AUTHOR_LIST_RE.search(titleblock)
    if m:
        leaks.append(f"  author-list-like pattern in title block: {m.group()[:80]}...")

    if leaks:
        print(f"FAIL: anti-leakage violations in {path}:", file=sys.stderr)
        for line in leaks:
            print(line, file=sys.stderr)
        print("\nThe Anti-Leakage Prompt (App. D.4) forbids these. Re-prompt the",
              file=sys.stderr)
        print("writing step with explicit instructions to remove these artifacts.",
              file=sys.stderr)
        return 1

    print(f"OK: no anti-leakage violations in {path}")
    return 0


def main() -> int:
    if len(sys.argv) != 2:
        print(__doc__, file=sys.stderr)
        return 2
    return check(sys.argv[1])


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

#!/usr/bin/env python3
"""
build_pdf.py — Fallback academic PDF builder (ReportLab).

Converts a Markdown research paper into a two-column IEEE-style PDF with:
  - Full-width title + abstract on page 1 (proper IEEE layout, no blank first page)
  - Two-column body starting below the abstract on the same page
  - Clickable in-text citations [N] that jump to the reference entry
  - Academic colour scheme (slate / blue)
  - Header/footer with short title and page numbers

Usage:
    python build_pdf.py --input paper.md --output paper.pdf
    python build_pdf.py --input paper.md --output paper.pdf --title-short "Short Title"
    python build_pdf.py --input paper.md --output paper.pdf --byline "NeurIPS 2026 Submission"
    python build_pdf.py --input paper.md --output paper.pdf --author "Alice Smith" --byline "ICML 2026"
    python build_pdf.py --input paper.md --output paper.pdf --demo-diagram

Requires: reportlab >= 4.0
"""

import argparse
import re
import sys
from pathlib import Path

from reportlab.lib import colors
from reportlab.lib.enums import TA_CENTER, TA_JUSTIFY, TA_LEFT
from reportlab.lib.pagesizes import letter
from reportlab.lib.styles import ParagraphStyle
from reportlab.lib.units import inch
from reportlab.platypus import (
    BaseDocTemplate,
    Frame,
    HRFlowable,
    NextPageTemplate,
    PageTemplate,
    Paragraph,
    Spacer,
    Table,
    TableStyle,
    FrameBreak,
)
from reportlab.platypus.flowables import AnchorFlowable

# ── Page geometry ─────────────────────────────────────────────────────────────

PAGE_W, PAGE_H = letter          # 8.5 × 11 inches
M_TOP    = 0.75 * inch
M_BOTTOM = 0.85 * inch
M_LEFT   = 0.75 * inch
M_RIGHT  = 0.75 * inch
COL_GAP  = 0.25 * inch

BODY_W  = PAGE_W - M_LEFT - M_RIGHT
COL_W   = (BODY_W - COL_GAP) / 2
BODY_H  = PAGE_H - M_TOP - M_BOTTOM

# How much vertical space the title+abstract strip gets on page 1.
# 4.5 in comfortably holds ~200-word abstract + title block.
TITLE_STRIP_H = 4.5 * inch
COL_H_P1      = BODY_H - TITLE_STRIP_H   # column height on page 1

# ── Brand colours ─────────────────────────────────────────────────────────────

C_DARK    = colors.HexColor("#0f172a")
C_BLUE    = colors.HexColor("#1d4ed8")
C_NAVY    = colors.HexColor("#1e3a5f")
C_RULE    = colors.HexColor("#cbd5e1")
C_MUTED   = colors.HexColor("#64748b")
C_BG_CODE = colors.HexColor("#f8fafc")
C_BG_BOX  = colors.HexColor("#eff6ff")
C_BOX_BDR = colors.HexColor("#bfdbfe")
C_LINK    = colors.HexColor("#1d4ed8")

# ── Styles ────────────────────────────────────────────────────────────────────

def make_styles() -> dict:
    return {
        "title": ParagraphStyle(
            "PTitle", fontName="Times-Bold", fontSize=17, leading=21,
            textColor=C_DARK, alignment=TA_CENTER, spaceAfter=3,
        ),
        "subtitle": ParagraphStyle(
            "PSub", fontName="Times-Italic", fontSize=9.5, leading=12,
            textColor=C_MUTED, alignment=TA_CENTER, spaceAfter=4,
        ),
        "abstract_h": ParagraphStyle(
            "PAbsH", fontName="Times-Bold", fontSize=9, leading=11,
            textColor=C_NAVY, alignment=TA_CENTER, spaceBefore=2, spaceAfter=3,
        ),
        "abstract": ParagraphStyle(
            "PAbs", fontName="Times-Roman", fontSize=8.5, leading=11.5,
            textColor=C_DARK, alignment=TA_JUSTIFY,
            leftIndent=20, rightIndent=20, spaceAfter=4,
        ),
        "section": ParagraphStyle(
            "PSec", fontName="Times-Bold", fontSize=10, leading=13,
            textColor=C_NAVY, spaceBefore=8, spaceAfter=3, keepWithNext=1,
        ),
        "subsection": ParagraphStyle(
            "PSSec", fontName="Times-BoldItalic", fontSize=9, leading=12,
            textColor=C_DARK, spaceBefore=5, spaceAfter=2, keepWithNext=1,
        ),
        "body": ParagraphStyle(
            "PBody", fontName="Times-Roman", fontSize=9, leading=12,
            textColor=C_DARK, alignment=TA_JUSTIFY,
            spaceAfter=4, firstLineIndent=12,
        ),
        "body_ni": ParagraphStyle(
            "PBodyNI", fontName="Times-Roman", fontSize=9, leading=12,
            textColor=C_DARK, alignment=TA_JUSTIFY, spaceAfter=4,
        ),
        "bullet": ParagraphStyle(
            "PBul", fontName="Times-Roman", fontSize=9, leading=12,
            textColor=C_DARK, alignment=TA_JUSTIFY,
            leftIndent=12, firstLineIndent=-8, spaceAfter=2,
        ),
        "code": ParagraphStyle(
            "PCode", fontName="Courier", fontSize=7.5, leading=10,
            textColor=C_DARK, leftIndent=8, spaceAfter=4,
            backColor=C_BG_CODE,
        ),
        "ref": ParagraphStyle(
            "PRef", fontName="Times-Roman", fontSize=8, leading=11,
            textColor=C_DARK, leftIndent=14, firstLineIndent=-14, spaceAfter=3,
        ),
        "diagram_label": ParagraphStyle(
            "PDiag", fontName="Helvetica-Bold", fontSize=8, leading=10,
            textColor=C_NAVY, alignment=TA_CENTER,
        ),
        "diagram_body": ParagraphStyle(
            "PDiagB", fontName="Helvetica", fontSize=7.5, leading=10,
            textColor=C_DARK, alignment=TA_CENTER,
        ),
        "diagram_caption": ParagraphStyle(
            "PDiagC", fontName="Times-Italic", fontSize=8, leading=10,
            textColor=C_MUTED, alignment=TA_CENTER, spaceBefore=4, spaceAfter=6,
        ),
    }


# ── Header / footer ───────────────────────────────────────────────────────────

def on_page(canvas, doc, short_title: str, byline: str = ""):
    canvas.saveState()
    y_h = PAGE_H - M_TOP + 8
    canvas.setStrokeColor(C_RULE)
    canvas.setLineWidth(0.5)
    canvas.line(M_LEFT, y_h, PAGE_W - M_RIGHT, y_h)
    canvas.setFont("Times-Italic", 7.5)
    canvas.setFillColor(C_MUTED)
    canvas.drawString(M_LEFT, y_h + 2, short_title)
    if byline:
        canvas.drawRightString(PAGE_W - M_RIGHT, y_h + 2, byline)
    y_f = M_BOTTOM - 12
    canvas.line(M_LEFT, y_f, PAGE_W - M_RIGHT, y_f)
    canvas.drawCentredString(PAGE_W / 2, y_f - 10, str(doc.page))
    canvas.restoreState()


# ── Page templates ────────────────────────────────────────────────────────────

def build_doc(out_path: str, short_title: str,
              title_meta: str = "", author_meta: str = "",
              byline: str = "") -> BaseDocTemplate:
    doc = BaseDocTemplate(
        out_path, pagesize=letter,
        leftMargin=M_LEFT, rightMargin=M_RIGHT,
        topMargin=M_TOP, bottomMargin=M_BOTTOM,
        title=title_meta or short_title,
        author=author_meta,
    )

    cb = lambda c, d: on_page(c, d, short_title, byline)

    # Page 1: full-width title+abstract strip at top, two columns below
    title_y = PAGE_H - M_TOP - TITLE_STRIP_H   # y-coordinate (from bottom) of bottom of title frame
    f_title = Frame(M_LEFT, title_y, BODY_W, TITLE_STRIP_H, id="title",
                    showBoundary=0)
    f_p1_l  = Frame(M_LEFT,                    M_BOTTOM, COL_W, COL_H_P1, id="p1_left",
                    showBoundary=0)
    f_p1_r  = Frame(M_LEFT + COL_W + COL_GAP,  M_BOTTOM, COL_W, COL_H_P1, id="p1_right",
                    showBoundary=0)

    # Pages 2+: pure two-column
    f_l = Frame(M_LEFT,                   M_BOTTOM, COL_W, BODY_H, id="left",  showBoundary=0)
    f_r = Frame(M_LEFT + COL_W + COL_GAP, M_BOTTOM, COL_W, BODY_H, id="right", showBoundary=0)

    pt_first  = PageTemplate(id="First",  frames=[f_title, f_p1_l, f_p1_r], onPage=cb)
    pt_twocol = PageTemplate(id="TwoCol", frames=[f_l, f_r],                 onPage=cb)

    doc.addPageTemplates([pt_first, pt_twocol])
    return doc


# ── Architecture diagram ──────────────────────────────────────────────────────

def make_arch_diagram(styles: dict, col_width: float) -> list:
    S = styles
    W = col_width - 8

    def cell(title, lines, bg):
        rows = [[Paragraph(title, S["diagram_label"])]] + \
               [[Paragraph(l, S["diagram_body"])] for l in lines]
        t = Table(rows, colWidths=[W - 12])
        t.setStyle(TableStyle([
            ("BACKGROUND",   (0, 0), (0, 0),  bg),
            ("BACKGROUND",   (0, 1), (-1, -1), colors.white),
            ("BOX",          (0, 0), (-1, -1), 0.75, C_BOX_BDR),
            ("INNERGRID",    (0, 0), (-1, -1), 0.3,  C_RULE),
            ("TOPPADDING",   (0, 0), (-1, -1), 2),
            ("BOTTOMPADDING",(0, 0), (-1, -1), 2),
            ("LEFTPADDING",  (0, 0), (-1, -1), 4),
            ("RIGHTPADDING", (0, 0), (-1, -1), 4),
        ]))
        return t

    warden = cell("Warden: Runtime Monitor", [
        "PreToolUse / PostToolUse hooks",
        "YAML policy engine  •  25+ rules",
        "Shell  •  File  •  Network  •  MCP  •  Prompt",
        "Observe mode  |  Enforce mode",
        "SQLite + JSONL audit trail",
    ], colors.HexColor("#dbeafe"))

    cloak = cell("Cloak: Secret Prevention", [
        "@@SECRET:name@@ placeholder convention",
        "PreToolUse: decloak at execution time",
        "sed-wrap scrubs stdout before recording",
        "UserPromptSubmit: intercepts pasted keys",
        "PostToolUse: scrubs MCP responses",
    ], colors.HexColor("#fef9c3"))

    sweep = cell("Sweep: Secret Cleanup", [
        "Gitleaks-powered residue scan",
        "Claude  •  Cursor  •  Windsurf caches",
        "AES-256-CBC vault  •  Redact / Restore",
        "Run on-demand or via Stop hook",
    ], colors.HexColor("#dcfce7"))

    agent_box = Table(
        [[Paragraph("IDE / Agent  (Claude Code  •  Cursor  •  Windsurf)", S["diagram_body"])]],
        colWidths=[W - 12],
    )
    agent_box.setStyle(TableStyle([
        ("BACKGROUND",   (0, 0), (-1, -1), colors.HexColor("#f1f5f9")),
        ("BOX",          (0, 0), (-1, -1), 1.0, C_NAVY),
        ("ALIGN",        (0, 0), (-1, -1), "CENTER"),
        ("TOPPADDING",   (0, 0), (-1, -1), 3),
        ("BOTTOMPADDING",(0, 0), (-1, -1), 3),
    ]))

    arrow = Paragraph("hooks", S["diagram_body"])

    outer = Table(
        [[agent_box], [arrow], [warden], [arrow], [cloak], [arrow], [sweep]],
        colWidths=[W],
    )
    outer.setStyle(TableStyle([
        ("ALIGN",         (0, 0), (-1, -1), "CENTER"),
        ("VALIGN",        (0, 0), (-1, -1), "MIDDLE"),
        ("TOPPADDING",    (0, 0), (-1, -1), 2),
        ("BOTTOMPADDING", (0, 0), (-1, -1), 2),
        ("LEFTPADDING",   (0, 0), (-1, -1), 6),
        ("RIGHTPADDING",  (0, 0), (-1, -1), 6),
    ]))

    return [
        Spacer(1, 6),
        outer,
        Paragraph(
            "Figure 1. Prismor Immunity Agent: three-layer defense architecture.",
            S["diagram_caption"],
        ),
        Spacer(1, 4),
    ]


# ── Inline markdown → ReportLab XML ──────────────────────────────────────────

# Citation pattern: [1], [1, 2], [1–3] etc.
_CIT_RE = re.compile(r'\[(\d[\d,\s\-–]*\d|\d)\]')

def md_inline(text: str, linkify_cites: bool = False) -> str:
    """
    Convert inline markdown to ReportLab paragraph XML.
    Backtick spans processed first to prevent italic regex firing on
    underscores inside code text (LD_PRELOAD, NODE_OPTIONS, etc.).
    If linkify_cites=True, [N] patterns become internal hyperlinks.
    """
    parts = re.split(r'`([^`]+)`', text)
    out = []
    for idx, part in enumerate(parts):
        if idx % 2 == 1:
            safe = (part.replace("&", "&")
                        .replace("<", "&lt;")
                        .replace(">", "&gt;"))
            out.append(f'<font name="Courier" size="8">{safe}</font>')
        else:
            safe = (part.replace("&", "&amp;")
                        .replace("<", "&lt;")
                        .replace(">", "&gt;"))
            safe = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', safe)
            safe = re.sub(r'\*\*\*(.+?)\*\*\*', r'<b><i>\1</i></b>', safe)
            safe = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', safe)
            safe = re.sub(r'(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)', r'<i>\1</i>', safe)
            if linkify_cites:
                # Link [N] → #ref_N  and  [N, M] → links for each number
                def _link_cit(m):
                    raw = m.group(0)       # e.g. "[1, 3]"
                    nums = re.findall(r'\d+', raw)
                    if len(nums) == 1:
                        n = nums[0]
                        return (f'<link href="#ref_{n}" '
                                f'color="{C_LINK.hexval()}">{raw}</link>')
                    # Multiple numbers: link each individually
                    inner = ", ".join(
                        f'<link href="#ref_{n}" color="{C_LINK.hexval()}">{n}</link>'
                        for n in nums
                    )
                    return f"[{inner}]"
                safe = _CIT_RE.sub(_link_cit, safe)
            out.append(safe)
    return "".join(out)


# ── Abstract extraction ───────────────────────────────────────────────────────

def extract_abstract(md_text: str) -> str:
    """Pull the abstract block out of the markdown. Returns plain text."""
    lines = md_text.splitlines()
    in_abs = False
    buf = []
    for line in lines:
        if line.startswith("## ") and line[3:].strip().lower() == "abstract":
            in_abs = True
            continue
        if in_abs:
            if line.startswith("## "):   # next section
                break
            if line.strip() in ("---", "***", "___"):
                break
            buf.append(line.strip())
    return " ".join(b for b in buf if b)


# ── ASCII table parser ────────────────────────────────────────────────────────

def _is_ascii_table(lines: list[str]) -> bool:
    """Return True if the block looks like a +---+ style ASCII table."""
    content = [l for l in lines if l.strip()]
    if len(content) < 2:
        return False
    sep_lines  = [l for l in content if re.match(r'^\s*\+[-+]+\+\s*$', l)]
    pipe_lines = [l for l in content if l.strip().startswith("|")]
    return len(sep_lines) >= 1 and len(pipe_lines) >= 1


def _col_widths_from_sep(sep_line: str, available_w: float) -> list[float]:
    """Derive proportional column widths from a +---+---+ separator line."""
    # Each segment between + markers gives a relative width in chars
    segs = re.split(r'\+', sep_line.strip())
    segs = [s for s in segs if s]   # remove empties at start/end
    if not segs:
        return []
    chars = [len(s) for s in segs]
    total = sum(chars)
    return [available_w * c / total for c in chars]


def _parse_rows(lines: list[str]) -> list[list[str]]:
    """
    Parse an ASCII table into logical rows.

    Separator lines (+---+) delimit rows.  Content lines (| ... |) between
    separators belong to the same logical row; multi-line cells are joined
    with a space.
    """
    logical_rows: list[list[str]] = []
    current_lines: list[list[str]] = []   # list of column-text lists

    def flush():
        if not current_lines:
            return
        # Merge multi-line cells column-by-column
        num_cols = max(len(r) for r in current_lines)
        merged = []
        for c in range(num_cols):
            parts = []
            for row_line in current_lines:
                if c < len(row_line):
                    v = row_line[c].strip()
                    if v:
                        parts.append(v)
            merged.append(" ".join(parts))
        logical_rows.append(merged)
        current_lines.clear()

    for line in lines:
        stripped = line.strip()
        if not stripped:
            continue
        if re.match(r'^\+[-+]+\+$', stripped):
            flush()
        elif stripped.startswith("|"):
            # Split on | and strip whitespace from each cell
            cells = [c.strip() for c in stripped.split("|")]
            # Remove empty strings that come from leading/trailing |
            cells = cells[1:-1] if len(cells) > 2 else cells
            current_lines.append(cells)

    flush()
    return logical_rows


def try_parse_ascii_table(code_lines: list[str],
                           styles: dict,
                           col_width: float) -> list | None:
    """
    If code_lines is an ASCII table, parse and return ReportLab flowables.
    Returns None if the block is not a table.
    """
    if not _is_ascii_table(code_lines):
        return None

    # Derive column widths from the first separator line
    sep_line = next((l for l in code_lines if re.match(r'^\s*\+[-+]+\+', l)), None)
    col_widths = _col_widths_from_sep(sep_line, col_width - 4) if sep_line else []

    rows = _parse_rows(code_lines)
    if not rows:
        return None

    S = styles

    # Build Paragraph cells
    tbl_style = ParagraphStyle(
        "TblCell", fontName="Helvetica", fontSize=7, leading=9,
        textColor=C_DARK, alignment=TA_LEFT,
    )
    hdr_style = ParagraphStyle(
        "TblHdr", fontName="Helvetica-Bold", fontSize=7, leading=9,
        textColor=colors.white, alignment=TA_LEFT,
    )

    para_rows = []
    for r_idx, row in enumerate(rows):
        style = hdr_style if r_idx == 0 else tbl_style
        para_rows.append([Paragraph(cell, style) for cell in row])

    # Normalise column count
    max_cols = max(len(r) for r in para_rows)
    for row in para_rows:
        while len(row) < max_cols:
            row.append(Paragraph("", tbl_style))

    # Column widths: use proportional if available, else equal
    if col_widths and len(col_widths) == max_cols:
        cw = col_widths
    else:
        cw = [col_width / max_cols] * max_cols

    t = Table(para_rows, colWidths=cw, repeatRows=1)
    t.setStyle(TableStyle([
        # Header row
        ("BACKGROUND",    (0, 0), (-1, 0),  C_NAVY),
        ("TEXTCOLOR",     (0, 0), (-1, 0),  colors.white),
        # Data rows alternating
        ("BACKGROUND",    (0, 1), (-1, -1), colors.white),
        ("ROWBACKGROUNDS",(0, 1), (-1, -1),
         [colors.white, colors.HexColor("#f1f5f9")]),
        # Grid
        ("BOX",           (0, 0), (-1, -1), 0.5, C_RULE),
        ("INNERGRID",     (0, 0), (-1, -1), 0.3, C_RULE),
        # Padding
        ("TOPPADDING",    (0, 0), (-1, -1), 3),
        ("BOTTOMPADDING", (0, 0), (-1, -1), 3),
        ("LEFTPADDING",   (0, 0), (-1, -1), 4),
        ("RIGHTPADDING",  (0, 0), (-1, -1), 4),
        ("VALIGN",        (0, 0), (-1, -1), "TOP"),
    ]))

    return [Spacer(1, 4), t, Spacer(1, 6)]


# ── Markdown → flowable list ──────────────────────────────────────────────────

def parse_markdown(md_text: str, styles: dict, col_width: float,
                   inject_diagram: bool = True,
                   skip_abstract: bool = False) -> list:
    """
    Parse markdown into ReportLab flowables.
    skip_abstract=True: skip the ## Abstract section (already in title block).
    """
    lines = md_text.splitlines()
    S = styles
    flowables = []

    in_abstract = False
    in_refs = False
    diagram_injected = False

    i = 0
    while i < len(lines):
        line = lines[i]

        # H1 title — skip (rendered in title block)
        if line.startswith("# ") and not line.startswith("## "):
            i += 1
            continue

        # Explicit diagram marker (only honored when inject_diagram is set)
        if line.strip() == "<!-- ARCH_DIAGRAM -->":
            if inject_diagram:
                flowables.extend(make_arch_diagram(S, col_width))
                diagram_injected = True
            i += 1
            continue

        # Horizontal rule
        if line.strip() in ("---", "***", "___"):
            if not in_abstract:
                flowables.append(HRFlowable(
                    width="100%", thickness=0.5, color=C_RULE,
                    spaceAfter=4, spaceBefore=4,
                ))
            i += 1
            continue

        # H2 section
        if line.startswith("## "):
            txt = line[3:].strip()

            if txt.lower() == "abstract":
                if skip_abstract:
                    in_abstract = True
                    i += 1
                    continue
                else:
                    in_abstract = False
                    flowables.append(Paragraph("Abstract", S["abstract_h"]))
                    i += 1
                    continue

            # Leaving abstract
            in_abstract = False

            if txt.lower().startswith("reference"):
                in_refs = True
            else:
                in_refs = False

            # Auto-inject diagram before §4
            if inject_diagram and not diagram_injected:
                m = re.match(r'^(\d+)\.', txt)
                if m and int(m.group(1)) >= 4:
                    flowables.extend(make_arch_diagram(S, col_width))
                    diagram_injected = True

            flowables.append(Paragraph(md_inline(txt), S["section"]))
            i += 1
            continue

        # H3 subsection
        if line.startswith("### "):
            in_abstract = False
            txt = line[4:].strip()
            flowables.append(Paragraph(md_inline(txt), S["subsection"]))
            i += 1
            continue

        # H4
        if line.startswith("#### "):
            txt = line[5:].strip()
            flowables.append(Paragraph(f"<b>{md_inline(txt)}</b>", S["body_ni"]))
            i += 1
            continue

        # Skip abstract lines when skip_abstract is True
        if in_abstract and skip_abstract:
            if line.startswith("## "):
                in_abstract = False
                continue   # re-process this line
            i += 1
            continue

        # Blank line
        if not line.strip():
            i += 1
            continue

        # Bullet
        if line.strip().startswith(("- ", "* ", "• ")):
            in_abstract = False
            txt = re.sub(r'^[\s\-\*•]+', '', line)
            flowables.append(Paragraph("• " + md_inline(txt, linkify_cites=True),
                                       S["bullet"]))
            i += 1
            continue

        # Numbered list
        if re.match(r'^\d+\.\s', line.strip()):
            in_abstract = False
            txt = re.sub(r'^\d+\.\s+', '', line.strip())
            flowables.append(Paragraph("• " + md_inline(txt, linkify_cites=True),
                                       S["bullet"]))
            i += 1
            continue

        # Fenced code block
        if line.strip().startswith("```"):
            in_abstract = False
            i += 1
            code_lines = []
            while i < len(lines) and not lines[i].strip().startswith("```"):
                code_lines.append(lines[i])
                i += 1
            i += 1
            if code_lines:
                # If the block looks like an ASCII table, render it properly
                tbl = try_parse_ascii_table(code_lines, S, col_width)
                if tbl is not None:
                    flowables.extend(tbl)
                else:
                    xml = "<br/>".join(
                        f'<font name="Courier" size="7">'
                        + l.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
                        + '</font>'
                        for l in code_lines[:25]
                    )
                    flowables.append(Paragraph(xml, S["code"]))
            continue

        # Reference line: [N] Author...
        if in_refs and re.match(r'^\[(\d+)\]', line.strip()):
            m = re.match(r'^\[(\d+)\]', line.strip())
            ref_n = m.group(1)
            # Insert an anchor so citations can jump here
            flowables.append(AnchorFlowable(f"ref_{ref_n}"))
            flowables.append(Paragraph(md_inline(line.strip()), S["ref"]))
            i += 1
            continue

        # Normal body text
        if line.strip() and not in_abstract:
            flowables.append(Paragraph(md_inline(line.strip(), linkify_cites=True),
                                       S["body"]))
        i += 1

    return flowables


# ── Title block (fills the full-width title frame on page 1) ─────────────────

def build_title_block(styles: dict, title_text: str, abstract_text: str,
                      byline: str = "") -> list:
    S = styles
    flows = [
        Spacer(1, 0.08 * inch),
        Paragraph(md_inline(title_text), S["title"]),
        Spacer(1, 0.04 * inch),
        HRFlowable(width="55%", thickness=1.5, color=C_BLUE,
                   hAlign="CENTER", spaceBefore=2, spaceAfter=3),
    ]
    if byline:
        flows.append(Paragraph(byline, S["subtitle"]))
    if abstract_text:
        flows += [
            Paragraph("Abstract", S["abstract_h"]),
            Paragraph(md_inline(abstract_text), S["abstract"]),
        ]
    flows += [Spacer(1, 0.06 * inch)]
    return flows


# ── Main ──────────────────────────────────────────────────────────────────────

def main() -> int:
    p = argparse.ArgumentParser(description=__doc__,
                                formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("--input",       required=True, help="Input Markdown file")
    p.add_argument("--output",      required=True, help="Output PDF path")
    p.add_argument("--title",       default=None,
                   help="Full paper title (read from first # heading if omitted)")
    p.add_argument("--title-short", dest="title_short", default=None,
                   help="Short title for header")
    p.add_argument("--byline",      default="",
                   help="Optional byline / venue strap shown under the title and "
                        "in the right side of the page header "
                        "(e.g. 'NeurIPS 2026 Submission' or 'Acme Corp · April 2026')")
    p.add_argument("--author",      default="",
                   help="Author string written into PDF metadata")
    p.add_argument("--demo-diagram", dest="demo_diagram", action="store_true",
                   help="Insert the legacy Prismor Immunity Agent demo "
                        "architecture diagram (auto-injected before §4 and on "
                        "<!-- ARCH_DIAGRAM --> markers). Off by default.")
    args = p.parse_args()

    md_path = Path(args.input)
    if not md_path.exists():
        print(f"ERROR: {md_path} not found", file=sys.stderr)
        return 1

    md_text = md_path.read_text(encoding="utf-8")

    # Extract title
    title = args.title
    if not title:
        m = re.search(r'^# (.+)', md_text, re.MULTILINE)
        title = m.group(1).strip() if m else md_path.stem

    short_title = args.title_short or (title[:60] + "..." if len(title) > 60 else title)

    # Extract abstract separately so it goes into the full-width title frame
    abstract_text = extract_abstract(md_text)

    styles = make_styles()
    doc    = build_doc(args.output, short_title,
                       title_meta=title, author_meta=args.author,
                       byline=args.byline)

    # Title block (full-width): title + abstract
    title_block = build_title_block(styles, title, abstract_text,
                                    byline=args.byline)

    # Body flowables: skip the abstract (already in title block)
    # FrameBreak pushes remaining title-frame space into the two-column area
    body_flows = (
        [FrameBreak()]   # end title frame, start left column on page 1
        + [NextPageTemplate("TwoCol")]
        + parse_markdown(
            md_text, styles, col_width=COL_W,
            inject_diagram=args.demo_diagram,
            skip_abstract=True,
        )
    )

    story = title_block + body_flows
    doc.build(story)

    size_kb = Path(args.output).stat().st_size // 1024
    print(f"PDF written: {args.output}  ({size_kb} KB)")
    return 0


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

#!/usr/bin/env python3
"""
check_idea_density.py — Pre-flight quality assessment for PaperOrchestra inputs.

Exit codes:
  0 — PASS: all checks passed
  1 — FAIL: one or more checks failed
  2 — File not found
"""

import argparse
import re
import sys


def tokenize(text: str) -> set:
    """Return a set of lowercase word tokens from text."""
    return set(re.findall(r"[a-z]+", text.lower()))


def jaccard(set_a: set, set_b: set) -> float:
    """Compute Jaccard similarity between two token sets."""
    if not set_a and not set_b:
        return 0.0
    intersection = len(set_a & set_b)
    union = len(set_a | set_b)
    return intersection / union if union > 0 else 0.0


def count_words(text: str) -> int:
    """Count whitespace-delimited words."""
    return len(text.split())


def count_markdown_tables(text: str) -> int:
    """Count markdown table separator lines (|---|)."""
    return len(re.findall(r"^\|[-| :]+\|", text, re.MULTILINE))


def count_numeric_values(text: str) -> int:
    r"""Count numeric values matching -?\d+\.?\d*."""
    return len(re.findall(r"-?\d+\.?\d*", text))


def has_hypothesis_signal(text: str) -> tuple:
    """Return (found: bool, matched_word: str)."""
    signals = ["hypothesis", "propose", "method", "approach", "contribution"]
    lower = text.lower()
    for signal in signals:
        if signal in lower:
            return True, signal
    return False, ""


def main():
    parser = argparse.ArgumentParser(
        description="Pre-flight density check for idea.md and experimental_log.md"
    )
    parser.add_argument("--idea", required=True, help="Path to idea.md")
    parser.add_argument("--log", required=True, help="Path to experimental_log.md")
    parser.add_argument(
        "--min-idea-words",
        type=int,
        default=50,
        help="Minimum word count for idea.md (default: 50)",
    )
    parser.add_argument(
        "--min-tables",
        type=int,
        default=1,
        help="Minimum number of markdown tables in experimental_log.md (default: 1)",
    )
    parser.add_argument(
        "--min-numeric-values",
        type=int,
        default=5,
        help="Minimum numeric values in experimental_log.md (default: 5)",
    )
    args = parser.parse_args()

    # Load files
    try:
        with open(args.idea, "r", encoding="utf-8") as f:
            idea_text = f.read()
    except FileNotFoundError:
        print(f"[ERROR] File not found: {args.idea}", file=sys.stderr)
        sys.exit(2)

    try:
        with open(args.log, "r", encoding="utf-8") as f:
            log_text = f.read()
    except FileNotFoundError:
        print(f"[ERROR] File not found: {args.log}", file=sys.stderr)
        sys.exit(2)

    failures = []

    # Check 1: idea.md word count
    idea_words = count_words(idea_text)
    if idea_words >= args.min_idea_words:
        print(f"[PASS] idea.md: {idea_words} words (min: {args.min_idea_words})")
    else:
        print(
            f"[FAIL] idea.md: {idea_words} words (min: {args.min_idea_words})"
        )
        failures.append(f"idea.md word count {idea_words} < {args.min_idea_words}")

    # Check 2: idea.md hypothesis signal
    found, matched = has_hypothesis_signal(idea_text)
    if found:
        print(f'[PASS] idea.md: contains hypothesis signal ("{matched}")')
    else:
        print(
            "[FAIL] idea.md: no hypothesis signal found "
            "(need one of: hypothesis, propose, method, approach, contribution)"
        )
        failures.append("idea.md missing hypothesis signal")

    # Check 3: experimental_log.md table count
    # Prose-style logs are valid as long as they contain enough numeric values
    # (checked next). A missing table is therefore a warning, not a hard fail.
    table_count = count_markdown_tables(log_text)
    if table_count >= args.min_tables:
        print(
            f"[PASS] experimental_log.md: {table_count} tables found "
            f"(min: {args.min_tables})"
        )
    else:
        print(
            f"[WARN] experimental_log.md: {table_count} markdown tables found "
            f"(min: {args.min_tables}). Prose-format logs are accepted when "
            f"numeric values meet the threshold — see Check 4."
        )

    # Check 4: experimental_log.md numeric values
    numeric_count = count_numeric_values(log_text)
    if numeric_count >= args.min_numeric_values:
        print(
            f"[PASS] experimental_log.md: {numeric_count} numeric values "
            f"(min: {args.min_numeric_values})"
        )
    else:
        print(
            f"[FAIL] experimental_log.md: {numeric_count} numeric values "
            f"(min: {args.min_numeric_values})"
        )
        failures.append(
            f"experimental_log.md numeric values {numeric_count} < {args.min_numeric_values}"
        )

    # Check 5: Jaccard similarity (not duplicates)
    idea_tokens = tokenize(idea_text)
    log_tokens = tokenize(log_text)
    similarity = jaccard(idea_tokens, log_tokens)
    if similarity < 0.5:
        print(
            f"[PASS] idea.md / experimental_log.md not duplicates "
            f"(Jaccard: {similarity:.2f})"
        )
    else:
        print(
            f"[FAIL] idea.md / experimental_log.md appear to be duplicates "
            f"(Jaccard: {similarity:.2f} >= 0.50)"
        )
        failures.append(
            f"idea.md and experimental_log.md too similar (Jaccard {similarity:.2f})"
        )

    # Summary
    print()
    if not failures:
        print("Pre-flight density check: PASS")
        sys.exit(0)
    else:
        print(f"Pre-flight density check: FAIL ({len(failures)} check(s) failed)")
        for f in failures:
            print(f"  - {f}")
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
check_tex_packages.py — Probe the local TeX installation for packages used
by common conference templates, and write tex_profile.json so downstream
agents can select the correct LaTeX patterns at generation time rather than
discovering failures during compilation.

Without this probe, the pipeline learns which packages are missing only after
a compile failure — requiring manual edits and re-runs. Running this script
once at pipeline startup eliminates that iteration.

Checks:
  cleveref   → if missing: use Figure~\\ref{} instead of \\cref{}
  nicefrac   → if missing: use a/b instead of \\nicefrac{a}{b}
  microtype  → if missing: omit \\usepackage{microtype}
  fontenc    → if missing: omit \\usepackage[T1]{fontenc} (avoids pcrr8t error)
  url        → if missing: omit \\usepackage{url}
  booktabs   → required for tables; warns if absent
  natbib     → required for plainnat bibliography style
  hyperref   → optional; common in many templates
  times      → optional; some templates request Times fonts
  lmodern    → fallback font package

Output: workspace/tex_profile.json
  {
    "available": ["booktabs", "natbib", ...],
    "missing": ["cleveref", "nicefrac", ...],
    "use_cleveref": false,
    "use_nicefrac": false,
    "use_microtype": false,
    "use_t1_fontenc": false,
    "tex_binary": "/Library/TeX/texbin/pdflatex",
    "checked_at": "2026-04-10T12:00:00"
  }

Usage:
    python check_tex_packages.py --out workspace/tex_profile.json
    python check_tex_packages.py --out workspace/tex_profile.json \\
        --tex-bin /Library/TeX/texbin/pdflatex
"""
import argparse
import datetime
import json
import os
import shutil
import subprocess
import sys
import tempfile

PACKAGES_TO_CHECK: list[tuple[str, str]] = [
    # (package_name, load_option)  — empty string means no option
    ("cleveref",  "capitalize"),
    ("nicefrac",  ""),
    ("microtype", ""),
    ("url",       ""),
    ("booktabs",  ""),
    ("natbib",    ""),
    ("hyperref",  ""),
    ("fontenc",   "T1"),
    ("times",     ""),
    ("lmodern",   ""),
]

TEX_BINARY_CANDIDATES = [
    "pdflatex",
    "/Library/TeX/texbin/pdflatex",
    "/usr/local/bin/pdflatex",
    "/usr/bin/pdflatex",
    "/opt/homebrew/bin/pdflatex",
]


def find_tex_binary(hint: str | None) -> str | None:
    candidates = ([hint] if hint else []) + TEX_BINARY_CANDIDATES
    for c in candidates:
        if shutil.which(c) or (os.path.isabs(c) and os.path.isfile(c)):
            return c
    return None


def probe_package(tex_binary: str, package: str, option: str = "") -> bool:
    """Compile a minimal .tex document that loads the package. Returns True if OK."""
    if option:
        use_line = f"\\usepackage[{option}]{{{package}}}"
    else:
        use_line = f"\\usepackage{{{package}}}"

    minimal = (
        "\\documentclass{article}\n"
        f"{use_line}\n"
        "\\begin{document}x\\end{document}\n"
    )
    with tempfile.TemporaryDirectory() as tmpdir:
        tex_path = os.path.join(tmpdir, "probe.tex")
        with open(tex_path, "w") as f:
            f.write(minimal)
        try:
            result = subprocess.run(
                [tex_binary, "-interaction=nonstopmode", "-halt-on-error",
                 "-output-directory", tmpdir, tex_path],
                capture_output=True,
                timeout=20,
            )
            return result.returncode == 0
        except (subprocess.TimeoutExpired, FileNotFoundError):
            return False


def build_fallback_profile(reason: str) -> dict:
    """Profile assuming nothing is available — used when pdflatex not found."""
    return {
        "available": [],
        "missing": [pkg for pkg, _ in PACKAGES_TO_CHECK],
        "use_cleveref": False,
        "use_nicefrac": False,
        "use_microtype": False,
        "use_t1_fontenc": False,
        "tex_binary": None,
        "error": reason,
        "checked_at": datetime.datetime.utcnow().isoformat(),
    }


def main() -> int:
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument("--out", required=True, help="Output tex_profile.json path")
    p.add_argument("--tex-bin", help="Path to pdflatex (auto-detected if omitted)")
    args = p.parse_args()

    tex_binary = find_tex_binary(args.tex_bin)
    if not tex_binary:
        print("WARN: pdflatex not found — writing fallback profile (all missing)",
              file=sys.stderr)
        profile = build_fallback_profile("pdflatex not found in PATH or known locations")
        os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True)
        with open(args.out, "w") as f:
            json.dump(profile, f, indent=2)
        return 1

    print(f"TeX binary: {tex_binary}")
    print("Probing packages...")
    available: list[str] = []
    missing: list[str] = []

    for pkg, opt in PACKAGES_TO_CHECK:
        ok = probe_package(tex_binary, pkg, option=opt)
        label = f"[{opt}]{pkg}" if opt else pkg
        status = "ok" if ok else "MISSING"
        print(f"  {label:30s} {status}")
        (available if ok else missing).append(pkg)

    profile = {
        "available": available,
        "missing": missing,
        "use_cleveref": "cleveref" in available,
        "use_nicefrac": "nicefrac" in available,
        "use_microtype": "microtype" in available,
        "use_t1_fontenc": "fontenc" in available,
        "tex_binary": tex_binary,
        "checked_at": datetime.datetime.utcnow().isoformat(),
    }

    os.makedirs(os.path.dirname(os.path.abspath(args.out)), exist_ok=True)
    with open(args.out, "w") as f:
        json.dump(profile, f, indent=2)

    print(f"\nProfile written → {args.out}")
    print(f"  use_cleveref   = {profile['use_cleveref']}")
    print(f"  use_nicefrac   = {profile['use_nicefrac']}")
    print(f"  use_microtype  = {profile['use_microtype']}")
    print(f"  use_t1_fontenc = {profile['use_t1_fontenc']}")
    if missing:
        print(f"  missing pkgs   = {', '.join(missing)}")

    return 0


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

#!/usr/bin/env python3
"""
claim_evidence_gate.py — Verify that quantitative claims in a paper draft
are grounded in the experimental log (AutoSci-inspired claim-evidence gate).

Analogous to orphan_cite_gate.py for citations: this gate extracts numeric
claims from the LaTeX draft and checks each against experimental_log.md.
Claims that cannot be corroborated are flagged as UNSUPPORTED.

This is a WARN gate (like validate_consistency.py), not a hard-stop gate:
  exit 0 — PASS: all extracted claims corroborated, or no claims extracted
  exit 1 — WARN: one or more claims could not be corroborated
  exit 2 — ERROR: input file missing or unreadable

Run during content-refinement Step 0 (pre-refinement integrity gate), after
ai_failure_modes checks.

Usage:
    python claim_evidence_gate.py \\
        --paper  workspace/drafts/paper.tex \\
        --log    workspace/inputs/experimental_log.md \\
        --out    workspace/claim_evidence_report.json

Output JSON:
    {
      "supported":   [ {claim, value, context, evidence_snippet} ],
      "unsupported": [ {claim, value, context} ],
      "uncertain":   [ {claim, value, context, reason} ],
      "summary": {
        "total": N,
        "supported": N, "unsupported": N, "uncertain": N
      }
    }
"""
import argparse
import json
import os
import re
import sys
from dataclasses import dataclass, asdict


# ── numeric claim patterns ────────────────────────────────────────────────────
# These patterns capture quantitative claims that typically appear in results:
#   - percentage improvements / accuracies          e.g. "improves by 3.2%"
#   - absolute metric values in result context      e.g. "achieves 87.4 mAP"
#   - ratio/fold improvements                       e.g. "2.5× faster"
#   - comparison operators with numbers             e.g. "outperforms X by 5.1"
# Patterns are intentionally broad; false positives are marked UNCERTAIN.

CLAIM_PATTERNS: list[re.Pattern] = [
    # percentage: "by 3.2%", "of 87.4%", "achieves 92.1%"
    re.compile(
        r"(?:by|of|achieves?|improves?\s+(?:by|to)|gains?|reduces?\s+(?:by|to)|"
        r"increases?\s+(?:by|to)|decreases?\s+(?:by|to)|accuracy|f1|recall|"
        r"precision|score|performance)\s+([+-]?\d+\.?\d*)\s*%",
        re.IGNORECASE,
    ),
    # ratio: "2.5× faster", "3× more", "×1.8"
    re.compile(r"(\d+\.?\d*)\s*[×x]\s*(?:faster|slower|more|less|better|worse)", re.IGNORECASE),
    re.compile(r"[×x]\s*(\d+\.?\d*)", re.IGNORECASE),
    # absolute metric with label: "87.4 mAP", "0.923 AUC", "12.3 BLEU"
    re.compile(r"(\d+\.?\d*)\s+(?:mAP|AUC|BLEU|ROUGE|CIDEr|FID|IS|top-\d+|WER|CER|IoU)",
               re.IGNORECASE),
    # "outperforms / exceeds / surpasses ... by N"
    re.compile(
        r"(?:outperforms?|exceeds?|surpasses?|beats?|better\s+than|"
        r"superior\s+to|lags?\s+behind)\s+[^.]{0,60}?\s+by\s+([+-]?\d+\.?\d*)",
        re.IGNORECASE,
    ),
    # LaTeX table cells: numbers in tabular environments (heuristic)
    re.compile(r"\\textbf\{(\d+\.?\d*)\}", re.IGNORECASE),
    re.compile(r"(\d{2,3}\.\d{1,2})\s*(?:\\\\|&|\})", re.IGNORECASE),
]

# Patterns that indicate a sentence is in a related-work / prior-work context
# (these numbers belong to cited papers, not our claims — mark as UNCERTAIN)
PRIOR_WORK_CONTEXT = re.compile(
    r"(?:previous|prior|existing|baselines?|compared\s+to|cite|cited|"
    r"et\s+al\.|\\cite\{|\\citet\{|\\citep\{|concurrent|related)",
    re.IGNORECASE,
)

# Minimum number of characters around a match to extract as context snippet
CONTEXT_WINDOW = 120


# ── helpers ───────────────────────────────────────────────────────────────────

@dataclass
class Claim:
    value: str
    context: str
    pattern_id: int
    is_prior_work: bool = False


def strip_latex_commands(text: str) -> str:
    """Remove common LaTeX markup to reduce false-positive matches."""
    text = re.sub(r"\\(?:label|ref|cite[tp]?|footnote|url|href)\{[^}]*\}", " ", text)
    text = re.sub(r"\\(?:begin|end)\{[^}]*\}", " ", text)
    text = re.sub(r"%.*$", "", text, flags=re.MULTILINE)  # strip comments
    return text


def _extract_sentence(text: str, match_start: int, match_end: int) -> str:
    """
    Return the sentence(s) most immediately containing the match.
    Uses sentence boundaries (. ! ?) rather than a fixed char window for the
    prior-work detection, so adjacent sections don't bleed in.
    """
    # Find the sentence start: last sentence-ending punctuation before the match
    before = text[:match_start]
    sent_start = max(
        before.rfind(". "),
        before.rfind(".\n"),
        before.rfind("! "),
        before.rfind("? "),
        before.rfind("\n\n"),
    )
    sent_start = sent_start + 1 if sent_start >= 0 else 0

    # Find the sentence end: next sentence-ending punctuation after the match
    after = text[match_end:]
    ends = [after.find(". "), after.find(".\n"), after.find("! "), after.find("? "),
            after.find("\n\n")]
    ends = [e for e in ends if e >= 0]
    sent_end = match_end + (min(ends) + 1 if ends else len(after))

    return text[sent_start:sent_end].replace("\n", " ").strip()


def extract_claims(tex: str) -> list[Claim]:
    """Extract all quantitative claims from LaTeX source."""
    clean = strip_latex_commands(tex)
    seen_values: set[str] = set()
    claims: list[Claim] = []

    for pid, pat in enumerate(CLAIM_PATTERNS):
        for m in pat.finditer(clean):
            val = m.group(1).strip()
            if not val or val in seen_values:
                continue
            # Skip very small numbers that are likely formatting (0, 1, 2…)
            try:
                if float(val) < 0.5:
                    continue
            except ValueError:
                pass

            # Sentence-bounded context for prior-work detection (prevents
            # adjacent-section bleed where "Previous methods..." in Related Work
            # falsely flags numbers in the Results section)
            sentence = _extract_sentence(clean, m.start(), m.end())
            is_prior = bool(PRIOR_WORK_CONTEXT.search(sentence))

            # Wider context for the human-readable context snippet
            start = max(0, m.start() - CONTEXT_WINDOW)
            end = min(len(clean), m.end() + CONTEXT_WINDOW)
            ctx = clean[start:end].replace("\n", " ").strip()

            claims.append(Claim(value=val, context=ctx, pattern_id=pid, is_prior_work=is_prior))
            seen_values.add(val)

    return claims


def build_number_index(log_text: str) -> set[str]:
    """
    Extract all numeric strings from experimental_log.md for O(1) lookup.
    Returns a set of string representations (e.g. "87.4", "3.2", "2.5").
    """
    nums: set[str] = set()
    for m in re.finditer(r"\b(\d+\.?\d*)\b", log_text):
        nums.add(m.group(1))
    return nums


def find_evidence(value: str, log_text: str) -> str | None:
    """
    Return a snippet from the log containing the given numeric value, or None.
    Matches whole decimal numbers (e.g. "87.4" matches "87.4" but not "87.41").
    """
    pat = re.compile(r"(?<!\d)" + re.escape(value) + r"(?!\d)")
    m = pat.search(log_text)
    if not m:
        return None
    start = max(0, m.start() - 80)
    end = min(len(log_text), m.end() + 80)
    return log_text[start:end].replace("\n", " ").strip()


# ── main ──────────────────────────────────────────────────────────────────────

def main() -> int:
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument("--paper", required=True, help="Path to paper.tex (draft)")
    p.add_argument("--log",   required=True, help="Path to experimental_log.md")
    p.add_argument("--out",   required=True, help="Output path for claim_evidence_report.json")
    args = p.parse_args()

    for path in (args.paper, args.log):
        if not os.path.exists(path):
            print(f"ERROR: file not found: {path}", file=sys.stderr)
            return 2

    with open(args.paper) as f:
        tex = f.read()
    with open(args.log) as f:
        log_text = f.read()

    claims = extract_claims(tex)
    log_nums = build_number_index(log_text)

    supported: list[dict] = []
    unsupported: list[dict] = []
    uncertain: list[dict] = []

    for c in claims:
        evidence = find_evidence(c.value, log_text)

        if c.is_prior_work:
            uncertain.append({
                "claim": c.context[:200],
                "value": c.value,
                "context": c.context,
                "reason": "appears in prior-work / citation context — not our claim",
            })
        elif evidence is not None:
            supported.append({
                "claim": c.context[:200],
                "value": c.value,
                "context": c.context,
                "evidence_snippet": evidence,
            })
        elif c.value in log_nums:
            # Number is in the log but not in matching sentence context — weak support
            supported.append({
                "claim": c.context[:200],
                "value": c.value,
                "context": c.context,
                "evidence_snippet": f"[number {c.value!r} found in log, no local snippet]",
            })
        else:
            unsupported.append({
                "claim": c.context[:200],
                "value": c.value,
                "context": c.context,
            })

    report = {
        "supported":   supported,
        "unsupported": unsupported,
        "uncertain":   uncertain,
        "summary": {
            "total":       len(claims),
            "supported":   len(supported),
            "unsupported": len(unsupported),
            "uncertain":   len(uncertain),
        },
    }

    os.makedirs(os.path.dirname(os.path.abspath(args.out)) or ".", exist_ok=True)
    with open(args.out, "w") as f:
        json.dump(report, f, indent=2, ensure_ascii=False)

    s = report["summary"]
    print(f"Claim-evidence gate: {s['total']} claims extracted")
    print(f"  supported:   {s['supported']}")
    print(f"  unsupported: {s['unsupported']}")
    print(f"  uncertain:   {s['uncertain']}")

    if unsupported:
        print("\nUNSUPPORTED claims (not found in experimental_log.md):")
        for item in unsupported:
            print(f"  [{item['value']}] {item['claim'][:120]}")
        print(f"\nWARN: {len(unsupported)} unsupported claim(s) — review before submission.")
        print(f"Full report: {args.out}")
        return 1

    print(f"PASS — all extracted claims are corroborated by experimental_log.md")
    return 0


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