Upload folder using huggingface_hub

README.md

@@ -1,3 +1,51 @@
----
-license: cc-by-4.0
----
+---
+license: cc-by-4.0
+language: en
+task_categories:
+  - text-classification
+  - question-answering
+---
+
+# DefExtra
+
+DefExtra contains 268 definition records (term, definition, context, type) from 75 papers. **We do not ship excerpts from papers** due to copyright. Instead, we ship legal markers and scripts that let users hydrate the dataset from their own PDFs.
+
+Why this workflow
+- We cannot redistribute copyrighted excerpts.
+- We therefore ship **only localization markers** plus scripts to reconstruct the text from user‑supplied PDFs.
+
+Quickstart (DefExtra hydration)
+1) Put PDFs in `pdfs/` (filename should match `paper_id`, DOI/PII alias, or arXiv ID).
+2) Start a GROBID server (see `docs/defextra_hydration.md`).
+3) Hydrate:
+```sh
+python scripts/hydrate_defextra.py \
+  --legal-csv data/defextra_legal.csv \
+  --pdf-dir pdfs \
+  --grobid-out grobid_out \
+  --output-csv defextra_hydrated.csv \
+  --report defextra_hydrated_report.txt \
+  --require-complete
+```
+
+Getting PDFs
+- See [`docs/get_pdfs.md`](docs/get_pdfs.md) for sources and a helper script that lists required PDFs.
+
+Data files
+- `data/defextra_legal.csv` / `data/defextra_legal.parquet`: DefExtra markers (no excerpts).
+
+Scripts
+- `scripts/hydrate_defextra.py`: hydrate DefExtra from PDFs + GROBID.
+- `scripts/pdf_to_grobid.py`: batch GROBID runner (requires a running GROBID server).
+- `scripts/list_defextra_pdfs.py`: list required PDFs + download links.
+- `scripts/build_defextra_test_pdfs.py`: build a test PDF set from a larger PDF pool.
+- `scripts/report_defextra_status.py`: summarize missing items by paper/definition.
+- `scripts/compare_defextra_csvs.py`: compare hydrated output to a reference.
+
+Documentation
+- `docs/defextra_hydration.md` (technical details, CLI flags, markers).
+- `docs/get_pdfs.md` (how to find PDFs).
+
+Notes
+- Hash IDs are typically Semantic Scholar paper IDs; many PDFs can be obtained from Semantic Scholar.
+- If you see PDF hash mismatch warnings, verify you have the correct paper version and rerun with `--allow-pdf-hash-mismatch` only after manual inspection.

config.json

@@ -0,0 +1,6 @@
+{
+    "grobid_server": "http://localhost:8070",
+    "grobid_port": 8070,
+    "batch_size": 1000,
+    "sleep_time": 5
+}

data/defextra_legal.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e43b04d733afd5acf066344c0d9364fb924b4959da4384e0b3eb2e04467563a1
+size 300352

docs/defextra_hydration.md

@@ -0,0 +1,89 @@
+# DefExtra hydration (technical)
+
+This dataset cannot ship excerpts. We ship markers only. Users supply PDFs and run hydration to reconstruct the definitions and contexts.
+
+```mermaid
+flowchart LR
+  A[data/defextra_legal.csv] --> B[hydrate_defextra.py]
+  B --> C[defextra_hydrated.csv]
+  subgraph GROBID
+    D[pdf_to_grobid.py] --> E[*.grobid.tei.xml]
+  end
+  B --> E
+```
+
+## Requirements
+- Python 3.10+
+- A running GROBID server (default: `http://localhost:8070`).
+  Example Docker run:
+  ```
+  docker run --rm -p 8070:8070 grobid/grobid:0.8.0
+  ```
+- Python packages used by scripts:
+  - `grobid-client-python`, `lxml`, `pdfplumber`, `pdfminer.six`, `PyPDF2`, `pyarrow`
+
+## Getting PDFs
+See `docs/get_pdfs.md` for sources and a helper script that lists required PDFs.
+
+## Quickstart
+1) Place your PDFs in `pdfs/`.
+2) Hydrate (runs GROBID unless `--skip-grobid`):
+```
+python scripts/hydrate_defextra.py \
+  --legal-csv data/defextra_legal.csv \
+  --pdf-dir pdfs \
+  --grobid-out grobid_out \
+  --output-csv defextra_hydrated.csv \
+  --report defextra_hydrated_report.txt \
+  --require-complete
+```
+
+## File naming expectations
+- Preferred: `<paper_id>.pdf` (the `paper_id` in the CSV).
+- DOI/arXiv/PII aliases are supported for common cases.
+- Hash IDs are often Semantic Scholar IDs; many PDFs can be downloaded from there.
+
+## GROBID configuration
+- By default, `scripts/pdf_to_grobid.py` will generate a temporary config that points to `http://localhost:8070`.
+- Use `--grobid-config config.json` to override the URL/timeout/batch size.
+
+## Hash mismatch behavior
+- The legal CSV includes hash markers to verify that the PDF content matches the paper version.
+- Default: **skip** PDFs with hash mismatches and report them.
+- Optional: `--allow-pdf-hash-mismatch` to continue anyway (use only after manual inspection).
+
+## Legal CSV schema (marker columns)
+- `definition_char_start`, `definition_char_end`: exact TEI substring span (optional).
+- `definition_match`: `exact`/`hash`/`missing` indicating how the TEI span was found.
+- `definition_hash64`, `definition_sha256`, `definition_token_count`: full span hash.
+- `definition_head_*`, `definition_mid_*`, `definition_tail_*`: anchor hashes (window size 12).
+- `definition_head_alt_*`, `definition_mid_alt_*`, `definition_tail_alt_*`: anchor hashes (window size 6).
+- Same fields exist for `context_*`.
+- `definition_preserve_linebreaks`, `context_preserve_linebreaks`:
+  keep line breaks when present in the manual copy (tables).
+- `definition_preserve_hyphenation`, `context_preserve_hyphenation`:
+  preserve line-break hyphenation when present.
+- `definition_has_bracket_citation`, `context_has_bracket_citation`:
+  whether the manual copy included `[12]`‑style citations.
+- `definition_has_paren_citation`, `context_has_paren_citation`:
+  whether the manual copy included `(Author, 2019)`‑style citations.
+- `definition_has_letter_digit`, `context_has_letter_digit`:
+  whether the manual copy contained letter‑digit runs like `bias4`.
+- `definition_end_punct`, `context_end_punct`:
+  trailing punctuation marker captured from the manual copy.
+
+## Comparing to the original (optional)
+If you maintain a private reference file with excerpts, you can compare:
+```
+python scripts/compare_defextra_csvs.py \
+  --postprocess \
+  --legal data/defextra_legal.csv \
+  --ref defextra_reference.csv \
+  --hyd defextra_hydrated.csv \
+  --report defextra_diff_report.txt \
+  --report-limit 0
+```
+
+Notes
+- Small mismatches are expected due to PDF/GROBID text normalization.
+- Missing exact TEI spans do **not** block hydration; hash/anchor markers are used as fallback.

docs/get_pdfs.md

@@ -0,0 +1,29 @@
+# Getting PDFs for DefExtra
+
+You must supply PDFs yourself. The dataset does **not** ship any copyrighted excerpts.
+
+## Recommended sources
+- **Semantic Scholar**: most `paper_id` values are Semantic Scholar IDs. You can open
+  `https://www.semanticscholar.org/paper/<paper_id>` and download the PDF when available.
+- **DOI landing pages**: use `https://doi.org/<paper_doi>` to locate the publisher PDF.
+- **arXiv**: use `https://arxiv.org/abs/<paper_arxiv>`.
+- **ACL Anthology**: if a `paper_id` looks like `2024.lrec-main.952`, use
+  `https://aclanthology.org/2024.lrec-main.952`.
+
+## Helper script
+Generate a CSV of required PDFs and links:
+```
+python scripts/list_defextra_pdfs.py \
+  --legal-csv data/defextra_legal.csv \
+  --output-csv defextra_required_pdfs.csv \
+  --output-md defextra_required_pdfs.md
+```
+
+The output includes:
+- `preferred_pdf_name` (the filename we recommend you use)
+- `alias_pdf_names` (acceptable filename aliases)
+- `url_semanticscholar`, `url_doi`, `url_arxiv`, `url_acl`
+
+## File naming
+Place PDFs in one folder and name them as `<paper_id>.pdf` when possible.
+DOI/arXiv/PII aliases are supported (see `alias_pdf_names` in the helper output).

scripts/__init__.py

@@ -0,0 +1 @@
+"""Utility package for dataset scripts."""

scripts/build_defextra_test_pdfs.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+# ruff: noqa: E402
+
+import argparse
+import csv
+import os
+import shutil
+import sys
+import re
+from pathlib import Path
+
+try:
+    from scripts.defextra_markers import (
+        doi_suffix,
+        normalize_arxiv,
+        normalize_doi,
+        normalize_paper_id,
+    )
+    from scripts.defextra_pdf_aliases import candidate_pdf_aliases
+except ModuleNotFoundError as exc:
+    if exc.name != "scripts":
+        raise
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    if str(PROJECT_ROOT) not in sys.path:
+        sys.path.insert(0, str(PROJECT_ROOT))
+    from scripts.defextra_markers import (
+        doi_suffix,
+        normalize_arxiv,
+        normalize_doi,
+        normalize_paper_id,
+    )
+    from scripts.defextra_pdf_aliases import candidate_pdf_aliases
+
+
+def _build_pdf_index(
+    source_dirs: list[Path],
+    *,
+    skip_dir: Path | None = None,
+) -> dict[str, Path]:
+    index: dict[str, Path] = {}
+    version_re = re.compile(r"^(?P<base>.+?)(v\d+)$", re.IGNORECASE)
+    arxiv_re = re.compile(r"^(?P<base>\d{4}\.\d{4,5})v\d+$", re.IGNORECASE)
+    pii_re = re.compile(r"(S\d{8,})", re.IGNORECASE)
+    for source_dir in source_dirs:
+        if not source_dir.exists():
+            continue
+        for suffix in ("*.pdf", "*.PDF"):
+            for path in source_dir.rglob(suffix):
+                if skip_dir is not None:
+                    try:
+                        path_abs = path.resolve()
+                    except (OSError, RuntimeError):
+                        path_abs = path.absolute()
+                    if skip_dir == path_abs or skip_dir in path_abs.parents:
+                        continue
+                stem = path.stem
+                for key in {stem, stem.lower()}:
+                    index.setdefault(key, path)
+                if stem.startswith("paper_"):
+                    stripped = stem[len("paper_") :]
+                    if stripped:
+                        index.setdefault(stripped, path)
+                        index.setdefault(stripped.lower(), path)
+                if stem.endswith("_fixed") or stem.endswith("-fixed"):
+                    base = stem[: -len("_fixed")] if stem.endswith("_fixed") else stem[: -len("-fixed")]
+                    if base:
+                        index[base] = path
+                        index[base.lower()] = path
+                        if base.startswith("paper_"):
+                            stripped_base = base[len("paper_") :]
+                            if stripped_base:
+                                index[stripped_base] = path
+                                index[stripped_base.lower()] = path
+                match = arxiv_re.match(stem)
+                if match:
+                    base = match.group("base")
+                    index.setdefault(base, path)
+                    index.setdefault(base.lower(), path)
+                match = version_re.match(stem)
+                if match:
+                    base = match.group("base")
+                    index.setdefault(base, path)
+                    index.setdefault(base.lower(), path)
+                pii_match = pii_re.search(stem)
+                if pii_match:
+                    pii = pii_match.group(1)
+                    index.setdefault(pii, path)
+                    index.setdefault(pii.lower(), path)
+    return index
+
+
+def _candidate_ids(paper_id: str, doi: str, arxiv: str) -> list[str]:
+    candidates = []
+    if paper_id:
+        candidates.append(paper_id)
+        candidates.append(normalize_paper_id(paper_id))
+    if doi:
+        norm_doi = normalize_doi(doi)
+        candidates.append(norm_doi)
+        candidates.append(doi_suffix(norm_doi))
+    if arxiv:
+        norm_arxiv = normalize_arxiv(arxiv)
+        candidates.append(norm_arxiv)
+    ordered: list[str] = []
+    seen = set()
+    for item in candidates:
+        value = (item or "").strip()
+        if not value:
+            continue
+        if value not in seen:
+            seen.add(value)
+            ordered.append(value)
+    for alias in candidate_pdf_aliases(paper_id, doi, arxiv):
+        value = (alias or "").strip()
+        if not value:
+            continue
+        if value not in seen:
+            seen.add(value)
+            ordered.append(value)
+    return ordered
+
+
+def _normalize_title(title: str) -> str:
+    return " ".join(title.lower().split())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Build a test-only PDF folder for DefExtra hydration.",
+    )
+    parser.add_argument(
+        "--legal-csv",
+        type=Path,
+        default=Path("results/paper_results/defextra_legal.csv"),
+        help="Legal DefExtra CSV with paper_ids.",
+    )
+    parser.add_argument(
+        "--source-dir",
+        action="append",
+        type=Path,
+        default=[
+            Path("ManualPDFsGROBID"),
+            Path("ManualPDFsGROBID/manual_pdfs/manual_pdfs"),
+        ],
+        help="Source PDF directory (can be repeated).",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path("ManualPDFsGROBID/test_pdfs"),
+        help="Output directory for test PDFs.",
+    )
+    parser.add_argument(
+        "--mode",
+        choices=("symlink", "copy"),
+        default="symlink",
+        help="Whether to symlink or copy PDFs into the output dir.",
+    )
+    parser.add_argument(
+        "--report",
+        type=Path,
+        default=None,
+        help="Optional report file listing missing PDFs.",
+    )
+    args = parser.parse_args()
+
+    if not args.legal_csv.exists():
+        raise SystemExit(f"Legal CSV not found: {args.legal_csv}")
+
+    pdf_index = _build_pdf_index(
+        args.source_dir,
+        skip_dir=args.output_dir.resolve(),
+    )
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    missing: list[str] = []
+    matched = 0
+    seen_ids: set[str] = set()
+
+    with args.legal_csv.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        rows = list(reader)
+
+    title_to_candidates: dict[str, list[str]] = {}
+    for row in rows:
+        title = _normalize_title(row.get("paper_title") or "")
+        if not title:
+            continue
+        paper_id = (row.get("paper_id") or "").strip()
+        doi = (row.get("paper_doi") or "").strip()
+        arxiv = (row.get("paper_arxiv") or "").strip()
+        candidates = _candidate_ids(paper_id, doi, arxiv)
+        if candidates:
+            title_to_candidates.setdefault(title, []).extend(candidates)
+
+    for row in rows:
+        paper_id = (row.get("paper_id") or "").strip()
+        if not paper_id or paper_id in seen_ids:
+            continue
+        seen_ids.add(paper_id)
+        doi = (row.get("paper_doi") or "").strip()
+        arxiv = (row.get("paper_arxiv") or "").strip()
+        title_key = _normalize_title(row.get("paper_title") or "")
+        path = None
+        for candidate in _candidate_ids(paper_id, doi, arxiv):
+            key = candidate.lower()
+            path = pdf_index.get(key) or pdf_index.get(f"paper_{key}")
+            if path is not None:
+                break
+        if path is None and title_key in title_to_candidates:
+            for candidate in title_to_candidates[title_key]:
+                key = candidate.lower()
+                path = pdf_index.get(key) or pdf_index.get(f"paper_{key}")
+                if path is not None:
+                    break
+        if path is None:
+            missing.append(paper_id)
+            continue
+
+        dest_id = normalize_paper_id(paper_id) or paper_id
+        dest = args.output_dir / f"{dest_id}.pdf"
+        if dest.is_symlink():
+            try:
+                current = dest.resolve(strict=True)
+            except (OSError, RuntimeError):
+                current = None
+            if current is None or current != path.resolve():
+                dest.unlink()
+            else:
+                matched += 1
+                continue
+        elif dest.exists():
+            matched += 1
+            continue
+
+        if args.mode == "copy":
+            shutil.copy2(path, dest)
+        else:
+            # Relative symlink keeps the test folder portable.
+            rel = Path(os.path.relpath(path, start=dest.parent))
+            dest.symlink_to(rel)
+        matched += 1
+
+    print(f"Matched PDFs: {matched}")
+    print(f"Missing PDFs: {len(missing)}")
+    if missing:
+        print("Missing IDs (first 20):", ", ".join(missing[:20]))
+
+    if args.report is not None:
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text("\n".join(missing) + "\n", encoding="utf-8")
+        print(f"Wrote report to {args.report}")
+
+
+if __name__ == "__main__":
+    main()

scripts/compare_defextra_csvs.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+# ruff: noqa: E402
+
+import argparse
+import csv
+import re
+import sys
+from pathlib import Path
+from typing import Dict, Tuple
+
+try:
+    from scripts.hydrate_defextra import (
+        _ensure_trailing_punct,
+        _postprocess_text,
+    )
+except ModuleNotFoundError as exc:
+    if exc.name != "scripts":
+        raise
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    if str(PROJECT_ROOT) not in sys.path:
+        sys.path.insert(0, str(PROJECT_ROOT))
+    from scripts.hydrate_defextra import (
+        _ensure_trailing_punct,
+        _postprocess_text,
+    )
+
+
+def _normalize_text(text: str) -> str:
+    if text is None:
+        return ""
+    value = text.replace("\u00ad", "")
+    value = re.sub(r"([A-Za-z])-\s+([A-Za-z])", r"\1\2", value)
+    value = re.sub(r"\s+", " ", value).strip()
+    return value
+
+
+def _normalize_punct(text: str) -> str:
+    if text is None:
+        return ""
+    value = text.replace("\u00ad", "")
+    value = re.sub(r"[^\w\s]", "", value)
+    value = re.sub(r"\\s+", " ", value).strip()
+    return value
+
+
+def _load(path: Path) -> Dict[Tuple[str, str], Dict[str, str]]:
+    with path.open(encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        return {(row["paper_id"], row["concept"]): row for row in reader}
+
+
+def _row_flag(
+    row: Dict[str, str],
+    key: str,
+    default: bool = False,
+) -> bool:
+    value = (row.get(key) or "").strip().lower()
+    if not value:
+        return default
+    return value == "true"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Compare DefExtra hydrated CSV against reference.",
+    )
+    parser.add_argument(
+        "--ref",
+        type=Path,
+        default=Path("results/paper_results/defextra_hf_tablefix.csv"),
+        help="Reference CSV path.",
+    )
+    parser.add_argument(
+        "--hyd",
+        type=Path,
+        default=Path(
+            "results/paper_results/defextra_hydrated_tablefix_test.csv",
+        ),
+        help="Hydrated CSV path.",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=5,
+        help="Number of mismatches to print.",
+    )
+    parser.add_argument(
+        "--report",
+        type=Path,
+        default=None,
+        help="Optional path to write a detailed mismatch report.",
+    )
+    parser.add_argument(
+        "--report-limit",
+        type=int,
+        default=0,
+        help="Limit mismatches written to report (0 = all).",
+    )
+    parser.add_argument(
+        "--legal",
+        type=Path,
+        default=Path("results/paper_results/defextra_legal_tablefix.csv"),
+        help="Legal CSV with token counts and linebreak flags.",
+    )
+    parser.add_argument(
+        "--postprocess",
+        action="store_true",
+        help="Apply hydration postprocessing to hydrated text before compare.",
+    )
+    args = parser.parse_args()
+
+    ref = _load(args.ref)
+    hyd = _load(args.hyd)
+    legal = _load(args.legal) if args.postprocess else {}
+
+    missing = [k for k in ref if k not in hyd]
+    extra = [k for k in hyd if k not in ref]
+
+    def_mismatch = []
+    ctx_mismatch = []
+    def_mismatch_norm = []
+    ctx_mismatch_norm = []
+    def_mismatch_punct = []
+    ctx_mismatch_punct = []
+
+    for key, ref_row in ref.items():
+        hyd_row = hyd.get(key)
+        if not hyd_row:
+            continue
+        if args.postprocess:
+            legal_row = legal.get(key, {})
+            def_expected = int(legal_row.get("definition_token_count") or 0)
+            ctx_expected = int(legal_row.get("context_token_count") or 0)
+            def_preserve = _row_flag(
+                legal_row,
+                "definition_preserve_linebreaks",
+            )
+            ctx_preserve = _row_flag(
+                legal_row,
+                "context_preserve_linebreaks",
+            )
+            def_preserve_hyphen = _row_flag(
+                legal_row,
+                "definition_preserve_hyphenation",
+            )
+            ctx_preserve_hyphen = _row_flag(
+                legal_row,
+                "context_preserve_hyphenation",
+            )
+            def_keep_bracket = _row_flag(
+                legal_row,
+                "definition_has_bracket_citation",
+                True,
+            )
+            def_keep_paren = _row_flag(
+                legal_row,
+                "definition_has_paren_citation",
+                True,
+            )
+            def_split_letter_digit = not _row_flag(
+                legal_row,
+                "definition_has_letter_digit",
+            )
+            ctx_keep_bracket = _row_flag(
+                legal_row,
+                "context_has_bracket_citation",
+                True,
+            )
+            ctx_keep_paren = _row_flag(
+                legal_row,
+                "context_has_paren_citation",
+                True,
+            )
+            ctx_split_letter_digit = not _row_flag(
+                legal_row,
+                "context_has_letter_digit",
+            )
+            hyd_row = dict(hyd_row)
+            hyd_row["definition"] = _ensure_trailing_punct(
+                _postprocess_text(
+                    hyd_row.get("definition", ""),
+                    def_expected,
+                    def_preserve,
+                    def_preserve_hyphen,
+                    def_keep_bracket,
+                    def_keep_paren,
+                    def_split_letter_digit,
+                ),
+                legal_row.get("definition_end_punct", ""),
+            )
+            hyd_row["context"] = _ensure_trailing_punct(
+                _postprocess_text(
+                    hyd_row.get("context", ""),
+                    ctx_expected,
+                    ctx_preserve,
+                    ctx_preserve_hyphen,
+                    ctx_keep_bracket,
+                    ctx_keep_paren,
+                    ctx_split_letter_digit,
+                ),
+                legal_row.get("context_end_punct", ""),
+            )
+        if ref_row.get("definition", "") != hyd_row.get("definition", ""):
+            def_mismatch.append(key)
+            if _normalize_text(
+                ref_row.get("definition", ""),
+            ) != _normalize_text(
+                hyd_row.get("definition", ""),
+            ):
+                def_mismatch_norm.append(key)
+            if _normalize_punct(ref_row.get("definition", "")) == _normalize_punct(
+                hyd_row.get("definition", ""),
+            ):
+                def_mismatch_punct.append(key)
+        if ref_row.get("context", "") != hyd_row.get("context", ""):
+            ctx_mismatch.append(key)
+            if _normalize_text(ref_row.get("context", "")) != _normalize_text(
+                hyd_row.get("context", ""),
+            ):
+                ctx_mismatch_norm.append(key)
+            if _normalize_punct(ref_row.get("context", "")) == _normalize_punct(
+                hyd_row.get("context", ""),
+            ):
+                ctx_mismatch_punct.append(key)
+
+    total_ref = len(ref)
+    total_hyd = len(hyd)
+    print(f"Reference rows: {total_ref}")
+    print(f"Hydrated rows: {total_hyd}")
+    print(f"Missing keys: {len(missing)}")
+    print(f"Extra keys: {len(extra)}")
+    print(f"Definition mismatches (exact): {len(def_mismatch)}")
+    print(f"Definition mismatches (normalized): {len(def_mismatch_norm)}")
+    print(f"Context mismatches (exact): {len(ctx_mismatch)}")
+    print(f"Context mismatches (normalized): {len(ctx_mismatch_norm)}")
+    if def_mismatch_punct:
+        print(
+            "Definition mismatches (punctuation-only): "
+            f"{len(def_mismatch_punct)}",
+        )
+    if ctx_mismatch_punct:
+        print(
+            "Context mismatches (punctuation-only): "
+            f"{len(ctx_mismatch_punct)}",
+        )
+
+    if args.limit <= 0:
+        return
+
+    shown = 0
+    for key in def_mismatch:
+        if shown >= args.limit:
+            break
+        ref_row = ref[key]
+        hyd_row = hyd[key]
+        print("\nDefinition mismatch:", key)
+        print("ref:", ref_row.get("definition", ""))
+        print("hyd:", hyd_row.get("definition", ""))
+        shown += 1
+
+    shown = 0
+    for key in ctx_mismatch:
+        if shown >= args.limit:
+            break
+        ref_row = ref[key]
+        hyd_row = hyd[key]
+        print("\nContext mismatch:", key)
+        print("ref:", ref_row.get("context", ""))
+        print("hyd:", hyd_row.get("context", ""))
+        shown += 1
+
+    if args.report is not None:
+        report_lines = []
+        report_lines.append(f"Missing keys: {len(missing)}")
+        report_lines.extend([f"- {k}" for k in missing])
+        report_lines.append("")
+        report_lines.append(
+            f"Definition mismatches (exact): {len(def_mismatch)}"
+        )
+        report_lines.append(
+            f"Definition mismatches (normalized): {len(def_mismatch_norm)}"
+        )
+        report_lines.append(
+            f"Definition mismatches (punctuation-only): {len(def_mismatch_punct)}"
+        )
+        report_lines.append(
+            f"Context mismatches (exact): {len(ctx_mismatch)}"
+        )
+        report_lines.append(
+            f"Context mismatches (normalized): {len(ctx_mismatch_norm)}"
+        )
+        report_lines.append(
+            f"Context mismatches (punctuation-only): {len(ctx_mismatch_punct)}"
+        )
+        report_lines.append("")
+
+        def_limit = args.report_limit or len(def_mismatch)
+        ctx_limit = args.report_limit or len(ctx_mismatch)
+
+        report_lines.append("Definition mismatches:")
+        for key in def_mismatch[:def_limit]:
+            ref_row = ref[key]
+            hyd_row = hyd[key]
+            report_lines.append(f"- {key[0]} | {key[1]}")
+            report_lines.append(f"  ref: {ref_row.get('definition','')}")
+            report_lines.append(f"  hyd: {hyd_row.get('definition','')}")
+        report_lines.append("")
+
+        report_lines.append("Context mismatches:")
+        for key in ctx_mismatch[:ctx_limit]:
+            ref_row = ref[key]
+            hyd_row = hyd[key]
+            report_lines.append(f"- {key[0]} | {key[1]}")
+            report_lines.append(f"  ref: {ref_row.get('context','')}")
+            report_lines.append(f"  hyd: {hyd_row.get('context','')}")
+
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text(
+            "\n".join(report_lines) + "\n",
+            encoding="utf-8",
+        )
+        print(f"Wrote report to {args.report}")
+
+
+if __name__ == "__main__":
+    main()

scripts/defextra_markers.py

@@ -0,0 +1,560 @@
+from __future__ import annotations
+
+import importlib
+import re
+import unicodedata
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Iterable, Optional
+
+try:
+    etree = importlib.import_module("lxml.etree")
+except Exception as exc:
+    raise RuntimeError(
+        "Missing lxml dependency. Install with `pip install lxml`.",
+    ) from exc
+
+NS = {"tei": "http://www.tei-c.org/ns/1.0"}
+
+BLOCK_TAGS = {
+    "head",
+    "p",
+    "item",
+    "title",
+    "label",
+    "figDesc",
+    "caption",
+    "cell",
+    "ab",
+    "note",
+    "quote",
+}
+
+HASH_BASE = 1_000_003
+HASH_MASK = (1 << 64) - 1
+HASH_VERSION = "tokhash_v2"
+ANCHOR_WINDOW = 12
+ANCHOR_WINDOW_ALT = 6
+
+
+def normalize_paper_id(paper_id: str) -> str:
+    raw = paper_id.strip()
+    if raw.lower().startswith("doi:"):
+        raw = raw[4:]
+    if raw.startswith("dx.doi.org/"):
+        raw = raw[len("dx.doi.org/") :]
+    if "doi.org/" in raw:
+        raw = raw.split("doi.org/", 1)[1]
+    if raw.startswith("http://") or raw.startswith("https://"):
+        match = re.search(r"arxiv\.org/(abs|pdf)/([^?#]+)", raw)
+        if match:
+            return match.group(2).replace(".pdf", "")
+        match = re.search(r"/pii/([^/?#]+)", raw)
+        if match:
+            return match.group(1)
+        match = re.search(r"10\.[0-9]+/([^?#]+)", raw)
+        if match:
+            return match.group(1)
+        parts = [p for p in re.split(r"[/?#]", raw) if p]
+        if parts:
+            return parts[-1]
+    match = re.search(r"10\.[0-9]+/([^\s]+)", raw)
+    if match:
+        return match.group(1)
+    return raw
+
+
+def normalize_arxiv(value: str) -> str:
+    cleaned = value.strip()
+    match = re.search(
+        r"(\d{4}\.\d{4,5}v\d+|[a-z-]+/\d{7}v\d+)",
+        cleaned,
+        re.I,
+    )
+    if match:
+        return match.group(1)
+    return cleaned.replace("arXiv:", "").strip()
+
+
+def normalize_doi(value: str) -> str:
+    cleaned = value.strip()
+    if cleaned.startswith("https://doi.org/"):
+        cleaned = cleaned[len("https://doi.org/") :]
+    if cleaned.startswith("http://doi.org/"):
+        cleaned = cleaned[len("http://doi.org/") :]
+    return cleaned.lower()
+
+
+def doi_suffix(value: str) -> str:
+    cleaned = normalize_doi(value)
+    match = re.search(r"10\.[0-9]+/(.+)", cleaned)
+    if match:
+        return match.group(1)
+    return cleaned
+
+
+def extract_ids_from_tei(path: Path) -> tuple[Optional[str], Optional[str]]:
+    try:
+        root = etree.parse(str(path)).getroot()
+    except (OSError, etree.XMLSyntaxError):
+        return None, None
+    bibl = root.find(
+        ".//tei:teiHeader/tei:fileDesc/tei:sourceDesc/tei:biblStruct",
+        namespaces=NS,
+    )
+    if bibl is None:
+        return None, None
+    idnos = bibl.findall(".//tei:idno", namespaces=NS)
+    doi = arxiv = None
+    for idno in idnos:
+        if idno.text is None:
+            continue
+        value = idno.text.strip()
+        if not value:
+            continue
+        id_type = (idno.get("type") or "").lower()
+        if doi is None and (
+            id_type == "doi" or value.lower().startswith("10.")
+        ):
+            doi = value
+        if arxiv is None and (
+            "arxiv" in id_type or value.lower().startswith("arxiv")
+        ):
+            arxiv = normalize_arxiv(value)
+    return doi, arxiv
+
+
+def extract_title_from_tei(path: Path) -> Optional[str]:
+    try:
+        root = etree.parse(str(path)).getroot()
+    except (OSError, etree.XMLSyntaxError):
+        return None
+    for path_expr in (
+        ".//tei:teiHeader/tei:fileDesc/tei:titleStmt/tei:title",
+        ".//tei:teiHeader/tei:fileDesc/tei:sourceDesc/tei:biblStruct/tei:analytic/tei:title",
+        ".//tei:teiHeader/tei:fileDesc/tei:sourceDesc/tei:biblStruct/tei:monogr/tei:title",
+    ):
+        node = root.find(path_expr, namespaces=NS)
+        if node is None:
+            continue
+        text = "".join(node.itertext()).strip()
+        if text:
+            return text
+    return None
+
+
+def extract_text_from_pdf(path: Path) -> str:
+    pdfplumber_module: Any | None
+    try:
+        pdfplumber_module = importlib.import_module("pdfplumber")
+    except Exception:
+        pdfplumber_module = None
+    pdfplumber_any: Any = pdfplumber_module
+    if pdfplumber_any is not None:
+        texts = []
+        with pdfplumber_any.open(str(path)) as pdf:
+            for page in pdf.pages:
+                page_text = page.extract_text() or ""
+                words_text = ""
+                try:
+                    words = page.extract_words(
+                        use_text_flow=True,
+                        keep_blank_chars=False,
+                    )
+                    if words:
+                        words_text = " ".join(w.get("text", "") for w in words)
+                except Exception:
+                    words_text = ""
+                if words_text and words_text not in page_text:
+                    if page_text:
+                        page_text = f"{page_text}\n{words_text}"
+                    else:
+                        page_text = words_text
+                texts.append(page_text)
+        return "\n\n".join(texts)
+    try:
+        from pdfminer.high_level import extract_text
+    except Exception:  # pragma: no cover - optional dependency
+        try:
+            from PyPDF2 import PdfReader
+        except Exception as py_exc:  # pragma: no cover
+            raise RuntimeError(
+                "PDF fallback extraction requires pdfminer.six "
+                "or PyPDF2. Install with `pip install pdfminer.six`.",
+            ) from py_exc
+        reader = PdfReader(str(path))
+        texts = []
+        for page in reader.pages:
+            texts.append(page.extract_text() or "")
+        return "\n\n".join(texts)
+    return extract_text(str(path))
+
+
+def build_tei_index(tei_dirs: Iterable[Path]) -> Dict[str, Path]:
+    index: Dict[str, Path] = {}
+    for tei_dir in tei_dirs:
+        if not tei_dir.exists():
+            continue
+        for path in tei_dir.glob("*.grobid.tei.xml"):
+            stem = path.name[: -len(".grobid.tei.xml")]
+            if stem.startswith("paper_"):
+                stem = stem[len("paper_") :]
+            index.setdefault(stem, path)
+    return index
+
+
+def _local_name(tag: str) -> str:
+    return tag.split("}", 1)[-1] if "}" in tag else tag
+
+
+def extract_blocks_from_tei(path: Path) -> list[str]:
+    root = etree.parse(str(path)).getroot()
+    blocks: list[str] = []
+
+    def add_blocks(elem) -> None:
+        tag = _local_name(elem.tag)
+        if tag in BLOCK_TAGS:
+            text = "".join(elem.itertext()).strip()
+            if text:
+                number = elem.get("n")
+                if number and tag in {"head", "label"}:
+                    text = f"{number} {text}".strip()
+                blocks.append(text)
+            return
+        for child in elem:
+            add_blocks(child)
+
+    for abstract in root.xpath(
+        ".//tei:teiHeader//tei:abstract",
+        namespaces=NS,
+    ):
+        add_blocks(abstract)
+
+    text_root = root.find(".//tei:text", namespaces=NS)
+    if text_root is not None:
+        add_blocks(text_root)
+    return blocks
+
+
+def _normalize_token(token: str) -> str:
+    return unicodedata.normalize("NFKC", token).lower()
+
+
+HYPHEN_CHARS = {
+    "-",
+    "\u2010",
+    "\u2011",
+    "\u2012",
+    "\u2013",
+    "\u2014",
+    "\u2212",
+}
+SOFT_HYPHEN = "\u00ad"
+
+
+def tokenize_text(
+    text: str,
+    *,
+    return_spans: bool = False,
+) -> tuple[list[str], Optional[list[tuple[int, int]]]]:
+    tokens: list[str] = []
+    spans: list[tuple[int, int]] = []
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if ch == SOFT_HYPHEN:
+            i += 1
+            continue
+        if ch.isalnum():
+            start = i
+            last_idx = i
+            last_alpha = ch.isalpha()
+            token_chars = [ch]
+            i += 1
+            while i < len(text):
+                ch = text[i]
+                if ch == SOFT_HYPHEN:
+                    i += 1
+                    continue
+                if ch.isalnum():
+                    is_alpha = ch.isalpha()
+                    if is_alpha != last_alpha:
+                        break
+                    token_chars.append(ch)
+                    last_idx = i
+                    last_alpha = is_alpha
+                    i += 1
+                    continue
+                if ch in HYPHEN_CHARS and last_alpha:
+                    j = i + 1
+                    while j < len(text) and text[j].isspace():
+                        j += 1
+                    if j < len(text) and text[j].isalpha():
+                        i = j
+                        continue
+                break
+            tokens.append(_normalize_token("".join(token_chars)))
+            if return_spans:
+                spans.append((start, last_idx + 1))
+        else:
+            i += 1
+    return tokens, spans if return_spans else None
+
+
+def hash_token(token: str) -> int:
+    import hashlib
+
+    digest = hashlib.blake2b(token.encode("utf-8"), digest_size=8).digest()
+    return int.from_bytes(digest, "big")
+
+
+def hash_token_sequence(tokens: list[str]) -> tuple[int, str, int]:
+    import hashlib
+
+    rolling = 0
+    normalized = [_normalize_token(token) for token in tokens]
+    for token in normalized:
+        rolling = ((rolling * HASH_BASE) + hash_token(token)) & HASH_MASK
+    joined = " ".join(normalized).encode("utf-8")
+    sha = hashlib.sha256(joined).hexdigest()
+    return rolling, sha, len(normalized)
+
+
+@dataclass
+class TokenIndex:
+    doc_text: str
+    tokens: list[str]
+    spans: list[tuple[int, int]]
+    token_hashes: list[int]
+    rolling_cache: dict[int, dict[int, list[int]]] = field(
+        default_factory=dict,
+    )
+
+    @classmethod
+    def from_text(cls, doc_text: str) -> "TokenIndex":
+        tokens, spans = tokenize_text(doc_text, return_spans=True)
+        token_hashes = [hash_token(t) for t in tokens]
+        return cls(
+            doc_text=doc_text,
+            tokens=tokens,
+            spans=spans or [],
+            token_hashes=token_hashes,
+        )
+
+    def _build_rolling_index(self, window: int) -> dict[int, list[int]]:
+        if window in self.rolling_cache:
+            return self.rolling_cache[window]
+        index: dict[int, list[int]] = {}
+        if window <= 0 or window > len(self.tokens):
+            self.rolling_cache[window] = index
+            return index
+
+        pow_base = 1
+        for _ in range(window - 1):
+            pow_base = (pow_base * HASH_BASE) & HASH_MASK
+
+        rolling = 0
+        for i in range(window):
+            rolling = (
+                (rolling * HASH_BASE) + self.token_hashes[i]
+            ) & HASH_MASK
+        index.setdefault(rolling, []).append(0)
+
+        for i in range(1, len(self.tokens) - window + 1):
+            remove = (self.token_hashes[i - 1] * pow_base) & HASH_MASK
+            rolling = (rolling - remove) & HASH_MASK
+            rolling = (
+                (rolling * HASH_BASE) + self.token_hashes[i + window - 1]
+            ) & HASH_MASK
+            index.setdefault(rolling, []).append(i)
+
+        self.rolling_cache[window] = index
+        return index
+
+    def _positions_for_hash(
+        self,
+        window: int,
+        target_hash: int,
+        target_sha: str,
+    ) -> list[int]:
+        index = self._build_rolling_index(window)
+        candidates = index.get(target_hash, [])
+        if not candidates:
+            return []
+        import hashlib
+
+        positions: list[int] = []
+        for start_idx in candidates:
+            end_idx = start_idx + window - 1
+            if end_idx >= len(self.tokens):
+                continue
+            token_slice = self.tokens[start_idx : start_idx + window]
+            sha = hashlib.sha256(
+                " ".join(token_slice).encode("utf-8"),
+            ).hexdigest()
+            if sha == target_sha:
+                positions.append(start_idx)
+        return positions
+
+    def find_token_span_by_hash(
+        self,
+        window: int,
+        target_hash: int,
+        target_sha: str,
+    ) -> Optional[tuple[int, int]]:
+        positions = self._positions_for_hash(window, target_hash, target_sha)
+        if not positions:
+            return None
+        start_idx = positions[0]
+        end_idx = start_idx + window - 1
+        return start_idx, end_idx
+
+    def find_token_positions_by_hash(
+        self,
+        window: int,
+        target_hash: int,
+        target_sha: str,
+    ) -> list[int]:
+        return self._positions_for_hash(window, target_hash, target_sha)
+
+    def find_span_by_hash(
+        self,
+        window: int,
+        target_hash: int,
+        target_sha: str,
+    ) -> Optional[tuple[int, int]]:
+        span = self.find_token_span_by_hash(window, target_hash, target_sha)
+        if span is None:
+            return None
+        start_idx, end_idx = span
+        start_char = self.spans[start_idx][0]
+        end_char = self.spans[end_idx][1]
+        return start_char, end_char
+        return None
+
+
+@dataclass
+class DocIndex:
+    doc_text: str
+    norm_space: str
+    norm_space_map: list[int]
+    norm_nospace: str
+    norm_nospace_map: list[int]
+
+    @classmethod
+    def from_tei(cls, tei_path: Path) -> "DocIndex":
+        blocks = extract_blocks_from_tei(tei_path)
+        doc_text = " ".join(blocks)
+        return cls.from_text(doc_text)
+
+    @classmethod
+    def from_text(cls, doc_text: str) -> "DocIndex":
+        norm_space: list[str] = []
+        norm_space_map: list[int] = []
+        norm_nospace: list[str] = []
+        norm_nospace_map: list[int] = []
+        prev_space = False
+        i = 0
+        while i < len(doc_text):
+            ch = doc_text[i]
+            if ch == "-" and i > 0 and doc_text[i - 1].isalpha():
+                j = i + 1
+                while j < len(doc_text) and doc_text[j].isspace():
+                    j += 1
+                if j < len(doc_text) and doc_text[j].isalpha():
+                    i = j
+                    continue
+            lower = ch.lower()
+            if lower.isalnum():
+                norm_space.append(lower)
+                norm_space_map.append(i)
+                norm_nospace.append(lower)
+                norm_nospace_map.append(i)
+                prev_space = False
+            else:
+                if not prev_space:
+                    norm_space.append(" ")
+                    norm_space_map.append(i)
+                    prev_space = True
+            i += 1
+
+        while norm_space and norm_space[0] == " ":
+            norm_space.pop(0)
+            norm_space_map.pop(0)
+        while norm_space and norm_space[-1] == " ":
+            norm_space.pop()
+            norm_space_map.pop()
+
+        return cls(
+            doc_text=doc_text,
+            norm_space="".join(norm_space),
+            norm_space_map=norm_space_map,
+            norm_nospace="".join(norm_nospace),
+            norm_nospace_map=norm_nospace_map,
+        )
+
+    def find_span(self, query: str) -> Optional[tuple[int, int, str]]:
+        if not query:
+            return None
+        n_q, n_q_ns = _normalize_query(query)
+        idx = self.norm_space.find(n_q)
+        if idx != -1:
+            start = self.norm_space_map[idx]
+            end = self.norm_space_map[idx + len(n_q) - 1] + 1
+            return start, end, "space"
+
+        trimmed = re.sub(r"^\s*\d+(?:\.\d+)*\s+", "", query)
+        if trimmed != query:
+            n_q_trim, n_q_trim_ns = _normalize_query(trimmed)
+            idx = self.norm_space.find(n_q_trim)
+            if idx != -1:
+                start = self.norm_space_map[idx]
+                end = self.norm_space_map[idx + len(n_q_trim) - 1] + 1
+                return start, end, "space_trim"
+            n_q_ns = n_q_trim_ns
+
+        idx = self.norm_nospace.find(n_q_ns)
+        if idx != -1:
+            start = self.norm_nospace_map[idx]
+            end = self.norm_nospace_map[idx + len(n_q_ns) - 1] + 1
+            return start, end, "nospace"
+        return None
+
+    def extract_span(self, start: Optional[int], end: Optional[int]) -> str:
+        if start is None or end is None:
+            return ""
+        if start < 0 or end > len(self.doc_text) or start >= end:
+            return ""
+        return self.doc_text[start:end]
+
+
+def _normalize_query(text: str) -> tuple[str, str]:
+    norm_space: list[str] = []
+    norm_nospace: list[str] = []
+    prev_space = False
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        if ch == "-" and i > 0 and text[i - 1].isalpha():
+            j = i + 1
+            while j < len(text) and text[j].isspace():
+                j += 1
+            if j < len(text) and text[j].isalpha():
+                i = j
+                continue
+        lower = ch.lower()
+        if lower.isalnum():
+            norm_space.append(lower)
+            norm_nospace.append(lower)
+            prev_space = False
+        else:
+            if not prev_space:
+                norm_space.append(" ")
+                prev_space = True
+        i += 1
+
+    while norm_space and norm_space[0] == " ":
+        norm_space.pop(0)
+    while norm_space and norm_space[-1] == " ":
+        norm_space.pop()
+    return "".join(norm_space), "".join(norm_nospace)

scripts/defextra_pdf_aliases.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+
+from scripts.defextra_markers import normalize_doi, normalize_paper_id
+
+PDF_ALIAS_MAP: dict[str, list[str]] = {
+    # Info Processing & Management DOI mapped to Elsevier PII stems.
+    "10.1016/j.ipm.2021.102505": [
+        "S0306457321000157",
+        "1-s2.0-S0306457321000157-main",
+        "S0957417423021437",
+        "1-s2.0-S0957417423021437-main",
+    ],
+    "j.ipm.2021.102505": [
+        "S0306457321000157",
+        "1-s2.0-S0306457321000157-main",
+        "S0957417423021437",
+        "1-s2.0-S0957417423021437-main",
+    ],
+    "dx.doi.org/https://doi.org/10.1016/j.ipm.2021.102505": [
+        "S0306457321000157",
+        "1-s2.0-S0306457321000157-main",
+        "S0957417423021437",
+        "1-s2.0-S0957417423021437-main",
+    ],
+}
+
+
+def candidate_pdf_aliases(
+    paper_id: str,
+    doi: str,
+    arxiv: str,
+) -> list[str]:
+    keys = {
+        (paper_id or "").strip(),
+        normalize_paper_id(paper_id or ""),
+        (doi or "").strip(),
+        normalize_doi(doi or ""),
+        (arxiv or "").strip(),
+    }
+    aliases: list[str] = []
+    for key in keys:
+        if not key:
+            continue
+        aliases.extend(PDF_ALIAS_MAP.get(key, []))
+    return aliases

scripts/hydrate_defextra.py

@@ -0,0 +1,1760 @@
+from __future__ import annotations
+
+# ruff: noqa: E402
+
+import argparse
+import csv
+import re
+import subprocess
+from pathlib import Path
+from typing import Dict, Optional
+
+import sys
+
+try:
+    from scripts.defextra_markers import (
+        DocIndex,
+        HASH_VERSION,
+        TokenIndex,
+        build_tei_index,
+        doi_suffix,
+        extract_ids_from_tei,
+        extract_text_from_pdf,
+        normalize_arxiv,
+        normalize_doi,
+        normalize_paper_id,
+        tokenize_text,
+    )
+    from scripts.defextra_pdf_aliases import candidate_pdf_aliases
+except ModuleNotFoundError as exc:
+    if exc.name != "scripts":
+        raise
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    if str(PROJECT_ROOT) not in sys.path:
+        sys.path.insert(0, str(PROJECT_ROOT))
+    from scripts.defextra_markers import (
+        DocIndex,
+        HASH_VERSION,
+        TokenIndex,
+        build_tei_index,
+        doi_suffix,
+        extract_ids_from_tei,
+        extract_text_from_pdf,
+        normalize_arxiv,
+        normalize_doi,
+        normalize_paper_id,
+        tokenize_text,
+    )
+    from scripts.defextra_pdf_aliases import candidate_pdf_aliases
+
+TRAILING_PUNCT = set(".,;:?!)]}\"'")
+END_PUNCT = {".", ",", ";", ":", "?", "!"}
+TRAILING_QUOTES = {"'", '"', "”", "’", ")", "]"}
+CITATION_BRACKET_RE = re.compile(r"\[[0-9][0-9,;\s\-–]*\]")
+CITATION_PAREN_RE = re.compile(r"\([^)]*\d{4}[^)]*\)")
+
+
+def _extend_span_end(doc_text: str, end: int) -> int:
+    if end < 0:
+        return end
+    limit = len(doc_text)
+    while end < limit and doc_text[end] in TRAILING_PUNCT:
+        end += 1
+    j = end
+    while j < limit and doc_text[j].isspace():
+        j += 1
+    if j < limit and doc_text[j] in TRAILING_PUNCT:
+        end = j + 1
+        while end < limit and doc_text[end] in TRAILING_PUNCT:
+            end += 1
+    return end
+
+
+def _extract_with_trailing_punct(
+    doc_text: str,
+    start: Optional[int],
+    end: Optional[int],
+) -> str:
+    if start is None or end is None:
+        return ""
+    if start < 0 or end > len(doc_text) or start >= end:
+        return ""
+    end = _extend_span_end(doc_text, end)
+    return doc_text[start:end]
+
+
+def _token_count(text: str) -> int:
+    tokens, _ = tokenize_text(text or "", return_spans=False)
+    return len(tokens)
+
+
+def _row_flag(row: dict, key: str, default: bool = False) -> bool:
+    value = (row.get(key) or "").strip().lower()
+    if not value:
+        return default
+    return value == "true"
+
+
+def _trim_pattern(
+    text: str,
+    expected: int,
+    pattern: re.Pattern[str],
+) -> str:
+    if not text or expected <= 0:
+        return text
+    while True:
+        current = _token_count(text)
+        best = text
+        best_diff = abs(current - expected)
+        improved = False
+        for match in pattern.finditer(text):
+            candidate = (
+                text[: match.start()] + " " + text[match.end() :]
+            ).strip()
+            diff = abs(_token_count(candidate) - expected)
+            if diff < best_diff:
+                best = candidate
+                best_diff = diff
+                improved = True
+        if not improved:
+            break
+        text = best
+        if _token_count(text) <= expected:
+            break
+    return text
+
+
+def _trim_citations(text: str, expected: int) -> str:
+    if not text or expected <= 0:
+        return text
+    current = _token_count(text)
+    if current <= expected:
+        return text
+    text = _trim_pattern(text, expected, CITATION_BRACKET_RE)
+    if _token_count(text) <= expected:
+        return text
+    text = _trim_pattern(text, expected, CITATION_PAREN_RE)
+    return text
+
+
+def _trim_to_token_count(text: str, expected: int) -> str:
+    if not text or expected <= 0:
+        return text
+    tokens, spans = tokenize_text(text, return_spans=True)
+    if not spans or len(spans) <= expected:
+        return text
+    end_idx = spans[expected - 1][1]
+    end_idx = _extend_span_end(text, end_idx)
+    return text[:end_idx].rstrip()
+
+
+def _cleanup_spacing(text: str) -> str:
+    if not text:
+        return text
+    value = text
+    value = value.replace("“", "\"").replace("”", "\"")
+    value = value.replace("’", "'").replace("‘", "'")
+    def _dash_repl(match: re.Match[str]) -> str:
+        run = match.group(0)
+        return "--" if len(run) >= 2 else "-"
+
+    value = re.sub(r"[\u2010-\u2015\u2212\u2043]+", _dash_repl, value)
+    value = value.replace("\ufb00", "ff")
+    value = value.replace("\ufb01", "fi")
+    value = value.replace("\ufb02", "fl")
+    value = value.replace("\ufb03", "ffi")
+    value = value.replace("\ufb04", "ffl")
+    value = value.replace("…", "...")
+    value = re.sub(r"-{3,}", "--", value)
+    value = re.sub(r"([a-z0-9])([.!?])(?=[A-Z])", r"\1\2 ", value)
+    value = re.sub(r"([A-Za-z]),(?=[A-Za-z])", r"\1, ", value)
+    value = re.sub(r"([A-Za-z0-9])([;:])(?=[A-Za-z])", r"\1\2 ", value)
+    value = re.sub(r"(\d)\s+(s)\b", r"\1\2", value)
+    value = re.sub(r"([0-9])([A-Za-z])", r"\1 \2", value)
+    value = re.sub(r"[ \t]+([,.;:!?])", r"\1", value)
+    value = re.sub(r"\(\s+", "(", value)
+    value = re.sub(r"\s+\)", ")", value)
+    value = re.sub(r"\[\s+", "[", value)
+    value = re.sub(r"\s+\]", "]", value)
+    value = re.sub(r"\)(?=[A-Za-z0-9])", ") ", value)
+    value = re.sub(r"\](?=[A-Za-z0-9])", "] ", value)
+
+    def _space_citation_commas(match: re.Match[str]) -> str:
+        inner = match.group(1)
+        inner = re.sub(r",(?!\\s)", ", ", inner)
+        return f"[{inner}]"
+
+    value = re.sub(r"\[([0-9,;\s\-–]+)\]", _space_citation_commas, value)
+    value = re.sub(r"[ \t]{2,}", " ", value)
+    return value
+
+
+def _normalize_whitespace(
+    text: str,
+    preserve_linebreaks: bool,
+) -> str:
+    if not text:
+        return text
+    value = _cleanup_spacing(text)
+    if preserve_linebreaks:
+        value = re.sub(r"[ \t]{2,}", " ", value)
+        return value
+    value = re.sub(r"\s+", " ", value).strip()
+    return value
+
+
+def _normalize_hyphenation(
+    text: str,
+    preserve_hyphenation: bool,
+) -> str:
+    if not text:
+        return text
+    if preserve_hyphenation:
+        return text
+    return re.sub(r"([A-Za-z])-\s+([A-Za-z])", r"\1\2", text)
+
+
+def _postprocess_text(
+    text: str,
+    expected_tokens: int,
+    preserve_linebreaks: bool,
+    preserve_hyphenation: bool,
+    keep_bracket_citations: bool = True,
+    keep_paren_citations: bool = True,
+    split_letter_digit: bool = True,
+) -> str:
+    value = text
+    if not keep_bracket_citations:
+        value = CITATION_BRACKET_RE.sub(" ", value)
+    if not keep_paren_citations:
+        value = CITATION_PAREN_RE.sub(" ", value)
+    value = _trim_citations(value, expected_tokens)
+    value = _trim_to_token_count(value, expected_tokens)
+    value = _cleanup_spacing(value)
+    if split_letter_digit:
+        value = re.sub(r"([A-Za-z])([0-9])", r"\1 \2", value)
+    value = _normalize_hyphenation(value, preserve_hyphenation)
+    return _normalize_whitespace(value, preserve_linebreaks)
+
+
+def _ensure_trailing_punct(text: str, end_punct: str) -> str:
+    if not text or not end_punct:
+        stripped = text.rstrip()
+        if not stripped:
+            return text
+        i = len(stripped) - 1
+        suffix = ""
+        while i >= 0 and stripped[i] in TRAILING_QUOTES:
+            suffix = stripped[i] + suffix
+            i -= 1
+        base = stripped[: i + 1]
+        if base and base[-1] in END_PUNCT:
+            base = base[:-1]
+        if base and suffix:
+            if ")" in suffix and "(" not in base:
+                suffix = suffix.replace(")", "")
+            if "]" in suffix and "[" not in base:
+                suffix = suffix.replace("]", "")
+        return f"{base}{suffix}"
+    stripped = text.rstrip()
+    if not stripped:
+        return text
+    i = len(stripped) - 1
+    suffix = ""
+    while i >= 0 and stripped[i] in TRAILING_QUOTES:
+        suffix = stripped[i] + suffix
+        i -= 1
+    base = stripped[: i + 1]
+    if base and base[-1] in END_PUNCT:
+        base = base[:-1] + end_punct
+    else:
+        base = f"{base}{end_punct}"
+    return f"{base}{suffix}"
+
+
+def _find_pdf_hash_span(
+    row: dict,
+    pdf_token_index: Optional[TokenIndex],
+    prefix: str,
+) -> Optional[tuple[int, int]]:
+    if pdf_token_index is None:
+        return None
+    spec = _select_hash_specs(row, prefix)
+    if spec:
+        span = pdf_token_index.find_span_by_hash(*spec)
+        if span:
+            return span
+    return None
+
+
+def _candidate_ids(paper_id: str, doi: str, arxiv: str) -> list[str]:
+    candidates = [
+        paper_id,
+        normalize_paper_id(paper_id),
+    ]
+    if doi:
+        candidates.append(doi)
+        candidates.append(doi_suffix(doi))
+    if arxiv:
+        candidates.append(arxiv)
+        candidates.append(normalize_arxiv(arxiv))
+    seen = set()
+    ordered = []
+    for item in candidates:
+        value = (item or "").strip()
+        if value and value not in seen:
+            seen.add(value)
+            ordered.append(value)
+    for alias in candidate_pdf_aliases(paper_id, doi, arxiv):
+        value = (alias or "").strip()
+        if value and value not in seen:
+            seen.add(value)
+            ordered.append(value)
+    return ordered
+
+
+def _normalize_title(title: str) -> str:
+    return " ".join(title.lower().split())
+
+
+def _build_meta_index(
+    tei_index: Dict[str, Path],
+) -> tuple[Dict[str, Path], Dict[str, Path]]:
+    doi_index: Dict[str, Path] = {}
+    arxiv_index: Dict[str, Path] = {}
+    for path in tei_index.values():
+        doi, arxiv = extract_ids_from_tei(path)
+        if doi:
+            doi_index.setdefault(normalize_doi(doi), path)
+            doi_index.setdefault(doi_suffix(doi), path)
+        if arxiv:
+            arxiv_index.setdefault(normalize_arxiv(arxiv), path)
+    return doi_index, arxiv_index
+
+
+def _resolve_tei_path(
+    paper_id: str,
+    doi: str,
+    arxiv: str,
+    tei_index: Dict[str, Path],
+    doi_index: Dict[str, Path],
+    arxiv_index: Dict[str, Path],
+) -> Optional[Path]:
+    for candidate in _candidate_ids(paper_id, doi, arxiv):
+        if candidate in tei_index:
+            return tei_index[candidate]
+        if candidate.startswith("paper_"):
+            stripped = candidate[len("paper_") :]
+            if stripped in tei_index:
+                return tei_index[stripped]
+    if doi:
+        doi_key = normalize_doi(doi)
+        if doi_key in doi_index:
+            return doi_index[doi_key]
+        doi_key = doi_suffix(doi)
+        if doi_key in doi_index:
+            return doi_index[doi_key]
+    if arxiv:
+        arxiv_key = normalize_arxiv(arxiv)
+        if arxiv_key in arxiv_index:
+            return arxiv_index[arxiv_key]
+    return None
+
+
+def _tei_stem(path: Path) -> str:
+    name = path.name
+    if name.endswith(".grobid.tei.xml"):
+        name = name[: -len(".grobid.tei.xml")]
+    return name
+
+
+def _build_pdf_index(pdf_dir: Path) -> Dict[str, Path]:
+    index: Dict[str, Path] = {}
+    if not pdf_dir.exists():
+        return index
+    version_re = re.compile(r"^(?P<base>.+?)(v\d+)$", re.IGNORECASE)
+    arxiv_re = re.compile(r"^(?P<base>\d{4}\.\d{4,5})v\d+$", re.IGNORECASE)
+    pii_re = re.compile(r"(S\d{8,})", re.IGNORECASE)
+    for suffix in ("*.pdf", "*.PDF"):
+        for path in pdf_dir.rglob(suffix):
+            stem = path.stem
+            index.setdefault(stem, path)
+            index.setdefault(normalize_paper_id(stem), path)
+            index.setdefault(f"paper_{stem}", path)
+            if stem.startswith("paper_"):
+                stripped = stem[len("paper_") :]
+                if stripped:
+                    index.setdefault(stripped, path)
+                    index.setdefault(normalize_paper_id(stripped), path)
+            if stem.endswith("_fixed") or stem.endswith("-fixed"):
+                base = stem[: -len("_fixed")] if stem.endswith("_fixed") else stem[: -len("-fixed")]
+                if base:
+                    index[base] = path
+                    index[normalize_paper_id(base)] = path
+                    index[f"paper_{base}"] = path
+                    if base.startswith("paper_"):
+                        stripped_base = base[len("paper_") :]
+                        if stripped_base:
+                            index[stripped_base] = path
+                            index[normalize_paper_id(stripped_base)] = path
+            match = arxiv_re.match(stem)
+            if match:
+                base = match.group("base")
+                index.setdefault(base, path)
+                index.setdefault(normalize_paper_id(base), path)
+            match = version_re.match(stem)
+            if match:
+                base = match.group("base")
+                index.setdefault(base, path)
+                index.setdefault(normalize_paper_id(base), path)
+            pii_match = pii_re.search(stem)
+            if pii_match:
+                pii = pii_match.group(1)
+                index.setdefault(pii, path)
+                index.setdefault(normalize_paper_id(pii), path)
+    return index
+
+
+def _select_hash_specs(
+    row: dict,
+    prefix: str,
+) -> Optional[tuple[int, int, str]]:
+    hash_version = (row.get("hash_version") or "").strip()
+    if hash_version and hash_version != HASH_VERSION:
+        return None
+    count = row.get(f"{prefix}_token_count") or ""
+    hash64 = row.get(f"{prefix}_hash64") or ""
+    sha = row.get(f"{prefix}_sha256") or ""
+    if not count or not hash64 or not sha:
+        return None
+    try:
+        return int(count), int(hash64), sha
+    except ValueError:
+        return None
+
+
+def _select_anchor_specs(
+    row: dict,
+    prefix: str,
+    position: str,
+) -> Optional[tuple[int, int, str]]:
+    hash_version = (row.get("hash_version") or "").strip()
+    if hash_version and hash_version != HASH_VERSION:
+        return None
+    count = row.get(f"{prefix}_{position}_token_count") or ""
+    hash64 = row.get(f"{prefix}_{position}_hash64") or ""
+    sha = row.get(f"{prefix}_{position}_sha256") or ""
+    if not count or not hash64 or not sha:
+        return None
+    try:
+        return int(count), int(hash64), sha
+    except ValueError:
+        return None
+
+
+def _select_anchor_spec_list(
+    row: dict,
+    prefix: str,
+    position: str,
+) -> list[tuple[int, int, str]]:
+    specs: list[tuple[int, int, str]] = []
+    primary = _select_anchor_specs(row, prefix, position)
+    if primary is not None:
+        specs.append(primary)
+    alt_count = row.get(f"{prefix}_{position}_alt_token_count") or ""
+    alt_hash = row.get(f"{prefix}_{position}_alt_hash64") or ""
+    alt_sha = row.get(f"{prefix}_{position}_alt_sha256") or ""
+    hash_version = (row.get("hash_version") or "").strip()
+    if hash_version and hash_version != HASH_VERSION:
+        return specs
+    if alt_count and alt_hash and alt_sha:
+        try:
+            specs.append((int(alt_count), int(alt_hash), alt_sha))
+        except ValueError:
+            pass
+    return specs
+
+
+def _match_doc_by_hash(
+    token_index: TokenIndex,
+    hash_specs: list[tuple[int, int, str]],
+) -> int:
+    score = 0
+    for window, hash64, sha in hash_specs:
+        if token_index.find_span_by_hash(window, hash64, sha):
+            score += 1
+    return score
+
+
+def _build_mid_candidates(
+    token_index: TokenIndex,
+    mid_specs: Optional[list[tuple[int, int, str]]],
+) -> list[tuple[int, int]]:
+    if not mid_specs:
+        return []
+    candidates: list[tuple[int, int]] = []
+    for spec in mid_specs:
+        for position in token_index.find_token_positions_by_hash(*spec):
+            candidates.append((position, spec[0]))
+    return candidates
+
+
+def _span_has_mid(
+    mid_candidates: list[tuple[int, int]],
+    start_idx: int,
+    end_idx: int,
+) -> bool:
+    for mid_start, mid_len in mid_candidates:
+        mid_end = mid_start + mid_len - 1
+        if mid_start >= start_idx and mid_end <= end_idx:
+            return True
+    return False
+
+
+def _find_span_by_anchors(
+    token_index: TokenIndex,
+    head_spec: Optional[tuple[int, int, str]],
+    tail_spec: Optional[tuple[int, int, str]],
+    expected_len: int,
+    mid_specs: Optional[list[tuple[int, int, str]]] = None,
+    *,
+    require_mid: bool = False,
+) -> Optional[tuple[int, int]]:
+    if head_spec is None or tail_spec is None:
+        return None
+    head_positions = token_index.find_token_positions_by_hash(*head_spec)
+    tail_positions = token_index.find_token_positions_by_hash(*tail_spec)
+    if not head_positions or not tail_positions:
+        return None
+    mid_candidates = []
+    if require_mid:
+        mid_candidates = _build_mid_candidates(token_index, mid_specs)
+        if not mid_candidates:
+            return None
+    best = None
+    best_diff = None
+    tol = max(5, int(expected_len * 0.3)) if expected_len else 10
+    min_len = max(1, expected_len // 2) if expected_len else 1
+    max_len = expected_len * 3 if expected_len else None
+    for head_start in head_positions:
+        head_end = head_start + head_spec[0] - 1
+        for tail_start in tail_positions:
+            tail_end = tail_start + tail_spec[0] - 1
+            if tail_end < head_end:
+                continue
+            length = tail_end - head_start + 1
+            if mid_candidates and not _span_has_mid(
+                mid_candidates,
+                head_start,
+                tail_end,
+            ):
+                continue
+            if expected_len:
+                if length < min_len or (max_len and length > max_len):
+                    continue
+                if length < expected_len - tol or length > expected_len + tol:
+                    continue
+                diff = abs(length - expected_len)
+            else:
+                diff = length
+            if best_diff is None or diff < best_diff:
+                best_diff = diff
+                best = (head_start, tail_end)
+    if best is None and expected_len:
+        for head_start in head_positions:
+            head_end = head_start + head_spec[0] - 1
+            for tail_start in tail_positions:
+                tail_end = tail_start + tail_spec[0] - 1
+                if tail_end < head_end:
+                    continue
+                length = tail_end - head_start + 1
+                if mid_candidates and not _span_has_mid(
+                    mid_candidates,
+                    head_start,
+                    tail_end,
+                ):
+                    continue
+                if length < min_len or (max_len and length > max_len):
+                    continue
+                diff = abs(length - expected_len)
+                if best_diff is None or diff < best_diff:
+                    best_diff = diff
+                    best = (head_start, tail_end)
+    if best is None:
+        return None
+    start_char = token_index.spans[best[0]][0]
+    end_char = token_index.spans[best[1]][1]
+    return start_char, end_char
+
+
+def _find_span_from_anchor(
+    token_index: TokenIndex,
+    anchor_spec: Optional[tuple[int, int, str]],
+    expected_len: int,
+    position: str,
+    mid_specs: Optional[list[tuple[int, int, str]]] = None,
+    *,
+    require_mid: bool = False,
+    require_unique: bool = False,
+) -> Optional[tuple[int, int]]:
+    if anchor_spec is None or expected_len <= 0:
+        return None
+    positions = token_index.find_token_positions_by_hash(*anchor_spec)
+    if not positions:
+        return None
+    if require_unique and len(positions) != 1:
+        return None
+    mid_candidates = []
+    if require_mid:
+        mid_candidates = _build_mid_candidates(token_index, mid_specs)
+        if not mid_candidates:
+            return None
+    if position == "tail":
+        positions = list(reversed(positions))
+    for anchor_start in positions:
+        if position == "head":
+            start_idx = anchor_start
+            end_idx = anchor_start + expected_len - 1
+        else:
+            anchor_end = anchor_start + anchor_spec[0] - 1
+            end_idx = anchor_end
+            start_idx = end_idx - expected_len + 1
+        if start_idx < 0 or end_idx >= len(token_index.tokens):
+            continue
+        if mid_candidates and not _span_has_mid(
+            mid_candidates,
+            start_idx,
+            end_idx,
+        ):
+            continue
+        start_char = token_index.spans[start_idx][0]
+        end_char = token_index.spans[end_idx][1]
+        return start_char, end_char
+    return None
+
+
+def _pick_best_doc(
+    token_indexes: Dict[Path, TokenIndex],
+    hash_specs: list[tuple[int, int, str]],
+) -> Optional[Path]:
+    best_path = None
+    best_score = 0
+    tie = False
+    for path, token_index in token_indexes.items():
+        score = _match_doc_by_hash(token_index, hash_specs)
+        if score > best_score:
+            best_score = score
+            best_path = path
+            tie = False
+        elif score == best_score and score > 0:
+            tie = True
+    if best_score == 0 or tie:
+        return None
+    return best_path
+
+
+def _pick_best_pdf(
+    pdf_paths: list[Path],
+    pdf_token_cache: Dict[Path, TokenIndex],
+    hash_specs: list[tuple[int, int, str]],
+) -> Optional[Path]:
+    best_path = None
+    best_score = 0
+    tie = False
+    for path in pdf_paths:
+        if path not in pdf_token_cache:
+            pdf_text = extract_text_from_pdf(path)
+            pdf_token_cache[path] = TokenIndex.from_text(pdf_text)
+        token_index = pdf_token_cache[path]
+        score = _match_doc_by_hash(token_index, hash_specs)
+        if score > best_score:
+            best_score = score
+            best_path = path
+            tie = False
+        elif score == best_score and score > 0:
+            tie = True
+    if best_score == 0 or tie:
+        return None
+    return best_path
+
+
+def _run_grobid(input_dir: Path, output_dir: Path, config: Path) -> None:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    cmd = [
+        sys.executable,
+        "scripts/pdf_to_grobid.py",
+        "--input_folder",
+        str(input_dir),
+        "--output_folder",
+        str(output_dir),
+    ]
+    if config and config.exists():
+        cmd.extend(["--config", str(config)])
+    subprocess.run(cmd, check=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Hydrate DefExtra legal CSV using user-provided PDFs.",
+    )
+    parser.add_argument(
+        "--legal-csv",
+        type=Path,
+        default=Path("results/paper_results/defextra_legal.csv"),
+        help="Legal DefExtra CSV with markers.",
+    )
+    parser.add_argument(
+        "--pdf-dir",
+        type=Path,
+        required=True,
+        help="Directory with user-provided PDFs.",
+    )
+    parser.add_argument(
+        "--grobid-out",
+        type=Path,
+        default=Path("outputs/defextra_grobid"),
+        help="Output directory for GROBID TEI files.",
+    )
+    parser.add_argument(
+        "--grobid-config",
+        type=Path,
+        default=Path("config.json"),
+        help="Optional GROBID client config path.",
+    )
+    parser.add_argument(
+        "--skip-grobid",
+        action="store_true",
+        help="Skip running GROBID (expects TEI files already present).",
+    )
+    parser.add_argument(
+        "--output-csv",
+        type=Path,
+        default=Path("results/paper_results/defextra_hydrated.csv"),
+        help="Output hydrated CSV with excerpts.",
+    )
+    parser.add_argument(
+        "--report",
+        type=Path,
+        default=None,
+        help="Optional report path for missing matches.",
+    )
+    parser.add_argument(
+        "--require-complete",
+        action="store_true",
+        help="Exit with error if any definition/context is missing.",
+    )
+    parser.add_argument(
+        "--filter-to-pdfs",
+        action="store_true",
+        help="Only process rows that can be mapped to a provided PDF.",
+    )
+    parser.add_argument(
+        "--allow-pdf-hash-mismatch",
+        action="store_true",
+        help=(
+            "Continue when a PDF filename matches but hash markers do not. "
+            "By default, such PDFs are skipped and reported."
+        ),
+    )
+    args = parser.parse_args()
+
+    if not args.legal_csv.exists():
+        raise SystemExit(f"Legal CSV not found: {args.legal_csv}")
+    if not args.pdf_dir.exists():
+        raise SystemExit(f"PDF dir not found: {args.pdf_dir}")
+
+    if not args.skip_grobid:
+        try:
+            _run_grobid(args.pdf_dir, args.grobid_out, args.grobid_config)
+        except subprocess.CalledProcessError:
+            raise SystemExit(
+                "GROBID processing failed. Ensure the GROBID server is running "
+                "and reachable (default: http://localhost:8070), or supply "
+                "--grobid-config with the correct server URL.",
+            )
+
+    tei_index = build_tei_index([args.grobid_out])
+    doi_index, arxiv_index = _build_meta_index(tei_index)
+    pdf_index = _build_pdf_index(args.pdf_dir)
+    doc_cache: Dict[str, Optional[DocIndex]] = {}
+    token_cache: Dict[str, Optional[TokenIndex]] = {}
+    tei_path_cache: Dict[str, Optional[Path]] = {}
+    pdf_token_cache: Dict[Path, TokenIndex] = {}
+    pdf_failed: set[Path] = set()
+
+    with args.legal_csv.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        legal_rows = list(reader)
+
+    paper_hashes: Dict[str, list[tuple[int, int, str]]] = {}
+    title_to_ids: Dict[str, list[str]] = {}
+    id_to_row: Dict[str, dict] = {}
+    for row in legal_rows:
+        paper_id = (row.get("paper_id") or "").strip()
+        if not paper_id:
+            continue
+        if paper_id not in id_to_row:
+            id_to_row[paper_id] = row
+        title_key = _normalize_title(row.get("paper_title") or "")
+        if title_key:
+            title_to_ids.setdefault(title_key, []).append(paper_id)
+        specs: list[tuple[int, int, str]] = []
+        for prefix in ("definition", "context"):
+            spec = _select_hash_specs(row, prefix)
+            if spec is None:
+                continue
+            token_count, _, _ = spec
+            if token_count >= 5:
+                specs.append(spec)
+        if specs:
+            paper_hashes.setdefault(paper_id, []).extend(specs)
+        for prefix in ("definition", "context"):
+            for position in ("head", "mid", "tail"):
+                for spec in _select_anchor_spec_list(row, prefix, position):
+                    if spec and spec[0] >= 5:
+                        paper_hashes.setdefault(paper_id, []).append(spec)
+
+    tei_token_indexes: Dict[Path, TokenIndex] = {}
+    allowed_stems = set(pdf_index.keys()) if pdf_index else set()
+    for tei_path in tei_index.values():
+        if allowed_stems:
+            stem = _tei_stem(tei_path)
+            stem_norm = normalize_paper_id(stem)
+            stem_stripped = (
+                stem[len("paper_") :] if stem.startswith("paper_") else stem
+            )
+            if (
+                stem not in allowed_stems
+                and stem_norm not in allowed_stems
+                and stem_stripped not in allowed_stems
+            ):
+                continue
+        try:
+            doc_index = DocIndex.from_tei(tei_path)
+        except Exception:
+            continue
+        tei_token_indexes[tei_path] = TokenIndex.from_text(doc_index.doc_text)
+
+    output_rows = []
+    missing_papers = set()
+    missing_defs = 0
+    missing_ctxs = 0
+    hydrated_from_pdf = 0
+    hydrated_from_anchor = 0
+    pdf_hash_mismatches: list[dict[str, str]] = []
+    pdf_hash_mismatch_seen: set[tuple[str, str]] = set()
+    missing_def_rows: list[dict] = []
+    missing_ctx_rows: list[dict] = []
+
+    for row in legal_rows:
+        paper_id = (row.get("paper_id") or "").strip()
+        doi = (row.get("paper_doi") or "").strip()
+        arxiv = (row.get("paper_arxiv") or "").strip()
+
+        if paper_id not in doc_cache:
+            tei_path = _resolve_tei_path(
+                paper_id,
+                doi,
+                arxiv,
+                tei_index,
+                doi_index,
+                arxiv_index,
+            )
+            if tei_path is None:
+                hash_specs = paper_hashes.get(paper_id, [])
+                if hash_specs:
+                    tei_path = _pick_best_doc(
+                        tei_token_indexes,
+                        hash_specs,
+                    )
+            if tei_path is None:
+                doc_cache[paper_id] = None
+                token_cache[paper_id] = None
+                tei_path_cache[paper_id] = None
+            else:
+                doc_index = DocIndex.from_tei(tei_path)
+                doc_cache[paper_id] = doc_index
+                token_cache[paper_id] = TokenIndex.from_text(
+                    doc_index.doc_text,
+                )
+                tei_path_cache[paper_id] = tei_path
+
+        doc_index = doc_cache.get(paper_id)
+        tei_token_index = token_cache.get(paper_id)
+        definition = ""
+        context = ""
+        pdf_token_index: Optional[TokenIndex] = None
+        pdf_path = None
+        tei_path = tei_path_cache.get(paper_id)
+        pdf_direct_match = False
+        if tei_path is not None:
+            stem = _tei_stem(tei_path)
+            pdf_path = pdf_index.get(stem) or pdf_index.get(
+                normalize_paper_id(stem),
+            )
+            if pdf_path is not None:
+                pdf_direct_match = True
+        if pdf_path is None:
+            for candidate in _candidate_ids(paper_id, doi, arxiv):
+                pdf_path = pdf_index.get(candidate)
+                if pdf_path:
+                    pdf_direct_match = True
+                    break
+        if pdf_path is None:
+            title_key = _normalize_title(row.get("paper_title") or "")
+            for other_id in title_to_ids.get(title_key, []):
+                if other_id == paper_id:
+                    continue
+                other_row = id_to_row.get(other_id, {})
+                other_doi = (other_row.get("paper_doi") or "").strip()
+                other_arxiv = (other_row.get("paper_arxiv") or "").strip()
+                for candidate in _candidate_ids(
+                    other_id,
+                    other_doi,
+                    other_arxiv,
+                ):
+                    pdf_path = pdf_index.get(candidate)
+                    if pdf_path:
+                        pdf_direct_match = True
+                        break
+                if pdf_path:
+                    break
+        hash_specs = paper_hashes.get(paper_id, [])
+        if pdf_path is not None and hash_specs:
+            if pdf_path not in pdf_token_cache:
+                pdf_text = extract_text_from_pdf(pdf_path)
+                pdf_token_cache[pdf_path] = TokenIndex.from_text(pdf_text)
+            pdf_token_index = pdf_token_cache[pdf_path]
+            if _match_doc_by_hash(pdf_token_index, hash_specs) == 0:
+                mismatch_key = (paper_id, str(pdf_path))
+                if mismatch_key not in pdf_hash_mismatch_seen:
+                    pdf_hash_mismatch_seen.add(mismatch_key)
+                    pdf_hash_mismatches.append(
+                        {"paper_id": paper_id, "pdf": str(pdf_path)},
+                    )
+                if not args.allow_pdf_hash_mismatch:
+                    if pdf_direct_match:
+                        print(
+                            f"Warning: PDF hash markers did not match for {pdf_path.name}; "
+                            "skipping PDF (use --allow-pdf-hash-mismatch to override).",
+                            file=sys.stderr,
+                        )
+                    pdf_path = None
+                    pdf_token_index = None
+                    pdf_direct_match = False
+                else:
+                    print(
+                        f"Warning: PDF hash markers did not match for {pdf_path.name}; "
+                        "continuing with direct filename match.",
+                        file=sys.stderr,
+                    )
+        if pdf_path is None and hash_specs:
+            pdf_paths = list({p for p in pdf_index.values()})
+            if pdf_paths:
+                pdf_path = _pick_best_pdf(
+                    pdf_paths,
+                    pdf_token_cache,
+                    hash_specs,
+                )
+
+        if args.filter_to_pdfs and pdf_path is None:
+            continue
+
+        if pdf_path is not None and pdf_path not in pdf_token_cache:
+            try:
+                pdf_text = extract_text_from_pdf(pdf_path)
+                pdf_token_cache[pdf_path] = TokenIndex.from_text(pdf_text)
+            except Exception as exc:
+                pdf_token_cache[pdf_path] = TokenIndex.from_text("")
+                if pdf_path not in pdf_failed:
+                    pdf_failed.add(pdf_path)
+                    print(
+                        f"Warning: PDF text extraction failed for {pdf_path.name}: {exc}",
+                        file=sys.stderr,
+                    )
+        pdf_token_index = pdf_token_cache.get(pdf_path) if pdf_path else None
+
+        if doc_index is None:
+            missing_papers.add(paper_id)
+        else:
+            def_start = row.get("definition_char_start") or ""
+            def_end = row.get("definition_char_end") or ""
+            ctx_start = row.get("context_char_start") or ""
+            ctx_end = row.get("context_char_end") or ""
+
+            if not definition and pdf_token_index:
+                span = _find_pdf_hash_span(row, pdf_token_index, "definition")
+                if span:
+                    definition = _extract_with_trailing_punct(
+                        pdf_token_index.doc_text,
+                        span[0],
+                        span[1],
+                    )
+                    hydrated_from_pdf += 1
+            if not definition and tei_token_index:
+                spec = _select_hash_specs(row, "definition")
+                if spec:
+                    span = tei_token_index.find_span_by_hash(*spec)
+                    if span:
+                        definition = _extract_with_trailing_punct(
+                            doc_index.doc_text,
+                            span[0],
+                            span[1],
+                        )
+                if not definition and not (def_start and def_end):
+                    head_specs = _select_anchor_spec_list(
+                        row,
+                        "definition",
+                        "head",
+                    )
+                    mid_specs = _select_anchor_spec_list(
+                        row,
+                        "definition",
+                        "mid",
+                    )
+                    tail_specs = _select_anchor_spec_list(
+                        row,
+                        "definition",
+                        "tail",
+                    )
+                    expected_len = int(row.get("definition_token_count") or 0)
+                    for head_spec in head_specs or [None]:
+                        for tail_spec in tail_specs or [None]:
+                            if head_spec is None or tail_spec is None:
+                                continue
+                            span = _find_span_by_anchors(
+                                tei_token_index,
+                                head_spec,
+                                tail_spec,
+                                expected_len,
+                                mid_specs,
+                                require_mid=True,
+                            )
+                            if span is None:
+                                span = _find_span_by_anchors(
+                                    tei_token_index,
+                                    head_spec,
+                                    tail_spec,
+                                    expected_len,
+                                )
+                            if span:
+                                definition = _extract_with_trailing_punct(
+                                    doc_index.doc_text,
+                                    span[0],
+                                    span[1],
+                                )
+                                break
+                        if definition:
+                            break
+                if not definition:
+                    head_specs = _select_anchor_spec_list(
+                        row,
+                        "definition",
+                        "head",
+                    )
+                    mid_specs = _select_anchor_spec_list(
+                        row,
+                        "definition",
+                        "mid",
+                    )
+                    tail_specs = _select_anchor_spec_list(
+                        row,
+                        "definition",
+                        "tail",
+                    )
+                    expected_len = int(row.get("definition_token_count") or 0)
+                    span = None
+                    for head_spec in head_specs:
+                        if mid_specs:
+                            span = _find_span_from_anchor(
+                                tei_token_index,
+                                head_spec,
+                                expected_len,
+                                "head",
+                                mid_specs,
+                                require_mid=True,
+                            )
+                            if span is None:
+                                span = _find_span_from_anchor(
+                                    tei_token_index,
+                                    head_spec,
+                                    expected_len,
+                                    "head",
+                                    mid_specs,
+                                    require_unique=True,
+                                )
+                        else:
+                            span = _find_span_from_anchor(
+                                tei_token_index,
+                                head_spec,
+                                expected_len,
+                                "head",
+                                mid_specs,
+                            )
+                        if span:
+                            break
+                    if span is None:
+                        for tail_spec in tail_specs:
+                            if mid_specs:
+                                span = _find_span_from_anchor(
+                                    tei_token_index,
+                                    tail_spec,
+                                    expected_len,
+                                    "tail",
+                                    mid_specs,
+                                    require_mid=True,
+                                )
+                                if span is None:
+                                    span = _find_span_from_anchor(
+                                        tei_token_index,
+                                        tail_spec,
+                                        expected_len,
+                                        "tail",
+                                        mid_specs,
+                                        require_unique=True,
+                                    )
+                            elif span is None:
+                                span = _find_span_from_anchor(
+                                    tei_token_index,
+                                    tail_spec,
+                                    expected_len,
+                                    "tail",
+                                    mid_specs,
+                                )
+                            if span:
+                                break
+                    if span:
+                        definition = _extract_with_trailing_punct(
+                            doc_index.doc_text,
+                            span[0],
+                            span[1],
+                        )
+            if not definition and def_start and def_end:
+                definition = _extract_with_trailing_punct(
+                    doc_index.doc_text,
+                    int(def_start),
+                    int(def_end),
+                )
+
+            if not context and pdf_token_index:
+                span = _find_pdf_hash_span(row, pdf_token_index, "context")
+                if span:
+                    context = _extract_with_trailing_punct(
+                        pdf_token_index.doc_text,
+                        span[0],
+                        span[1],
+                    )
+                    hydrated_from_pdf += 1
+
+            if not context and tei_token_index:
+                spec = _select_hash_specs(row, "context")
+                if spec:
+                    span = tei_token_index.find_span_by_hash(*spec)
+                    if span:
+                        context = _extract_with_trailing_punct(
+                            doc_index.doc_text,
+                            span[0],
+                            span[1],
+                        )
+                if not context and not (ctx_start and ctx_end):
+                    head_specs = _select_anchor_spec_list(
+                        row,
+                        "context",
+                        "head",
+                    )
+                    mid_specs = _select_anchor_spec_list(
+                        row,
+                        "context",
+                        "mid",
+                    )
+                    tail_specs = _select_anchor_spec_list(
+                        row,
+                        "context",
+                        "tail",
+                    )
+                    expected_len = int(row.get("context_token_count") or 0)
+                    for head_spec in head_specs or [None]:
+                        for tail_spec in tail_specs or [None]:
+                            if head_spec is None or tail_spec is None:
+                                continue
+                            span = _find_span_by_anchors(
+                                tei_token_index,
+                                head_spec,
+                                tail_spec,
+                                expected_len,
+                                mid_specs,
+                                require_mid=True,
+                            )
+                            if span is None:
+                                span = _find_span_by_anchors(
+                                    tei_token_index,
+                                    head_spec,
+                                    tail_spec,
+                                    expected_len,
+                                )
+                            if span:
+                                context = _extract_with_trailing_punct(
+                                    doc_index.doc_text,
+                                    span[0],
+                                    span[1],
+                                )
+                                break
+                        if context:
+                            break
+                if not context:
+                    head_specs = _select_anchor_spec_list(
+                        row,
+                        "context",
+                        "head",
+                    )
+                    mid_specs = _select_anchor_spec_list(
+                        row,
+                        "context",
+                        "mid",
+                    )
+                    tail_specs = _select_anchor_spec_list(
+                        row,
+                        "context",
+                        "tail",
+                    )
+                    expected_len = int(row.get("context_token_count") or 0)
+                    span = None
+                    for head_spec in head_specs:
+                        if mid_specs:
+                            span = _find_span_from_anchor(
+                                tei_token_index,
+                                head_spec,
+                                expected_len,
+                                "head",
+                                mid_specs,
+                                require_mid=True,
+                            )
+                            if span is None:
+                                span = _find_span_from_anchor(
+                                    tei_token_index,
+                                    head_spec,
+                                    expected_len,
+                                    "head",
+                                    mid_specs,
+                                    require_unique=True,
+                                )
+                        else:
+                            span = _find_span_from_anchor(
+                                tei_token_index,
+                                head_spec,
+                                expected_len,
+                                "head",
+                                mid_specs,
+                            )
+                        if span:
+                            break
+                    if span is None:
+                        for tail_spec in tail_specs:
+                            if mid_specs:
+                                span = _find_span_from_anchor(
+                                    tei_token_index,
+                                    tail_spec,
+                                    expected_len,
+                                    "tail",
+                                    mid_specs,
+                                    require_mid=True,
+                                )
+                                if span is None:
+                                    span = _find_span_from_anchor(
+                                        tei_token_index,
+                                        tail_spec,
+                                        expected_len,
+                                        "tail",
+                                        mid_specs,
+                                        require_unique=True,
+                                    )
+                            elif span is None:
+                                span = _find_span_from_anchor(
+                                    tei_token_index,
+                                    tail_spec,
+                                    expected_len,
+                                    "tail",
+                                    mid_specs,
+                                )
+                            if span:
+                                break
+                    if span:
+                        context = _extract_with_trailing_punct(
+                            doc_index.doc_text,
+                            span[0],
+                            span[1],
+                        )
+            if not context and ctx_start and ctx_end:
+                context = _extract_with_trailing_punct(
+                    doc_index.doc_text,
+                    int(ctx_start),
+                    int(ctx_end),
+                )
+
+        if not definition and pdf_path is not None and pdf_token_index:
+            spec = _select_hash_specs(row, "definition")
+            if spec:
+                span = pdf_token_index.find_span_by_hash(*spec)
+                if span:
+                    definition = _extract_with_trailing_punct(
+                        pdf_token_index.doc_text,
+                        span[0],
+                        span[1],
+                    )
+                    hydrated_from_pdf += 1
+            if not definition:
+                head_specs = _select_anchor_spec_list(
+                    row,
+                    "definition",
+                    "head",
+                )
+                mid_specs = _select_anchor_spec_list(
+                    row,
+                    "definition",
+                    "mid",
+                )
+                tail_specs = _select_anchor_spec_list(
+                    row,
+                    "definition",
+                    "tail",
+                )
+                expected_len = int(row.get("definition_token_count") or 0)
+                for head_spec in head_specs or [None]:
+                    for tail_spec in tail_specs or [None]:
+                        if head_spec is None or tail_spec is None:
+                            continue
+                        span = _find_span_by_anchors(
+                            pdf_token_index,
+                            head_spec,
+                            tail_spec,
+                            expected_len,
+                            mid_specs,
+                            require_mid=True,
+                        )
+                        if span is None:
+                            span = _find_span_by_anchors(
+                                pdf_token_index,
+                                head_spec,
+                                tail_spec,
+                                expected_len,
+                            )
+                        if span:
+                            definition = _extract_with_trailing_punct(
+                                pdf_token_index.doc_text,
+                                span[0],
+                                span[1],
+                            )
+                            hydrated_from_pdf += 1
+                            hydrated_from_anchor += 1
+                            break
+                    if definition:
+                        break
+            if not definition:
+                head_specs = _select_anchor_spec_list(
+                    row,
+                    "definition",
+                    "head",
+                )
+                mid_specs = _select_anchor_spec_list(
+                    row,
+                    "definition",
+                    "mid",
+                )
+                tail_specs = _select_anchor_spec_list(
+                    row,
+                    "definition",
+                    "tail",
+                )
+                expected_len = int(row.get("definition_token_count") or 0)
+                span = None
+                for head_spec in head_specs:
+                    if mid_specs:
+                        span = _find_span_from_anchor(
+                            pdf_token_index,
+                            head_spec,
+                            expected_len,
+                            "head",
+                            mid_specs,
+                            require_mid=True,
+                        )
+                        if span is None:
+                            span = _find_span_from_anchor(
+                                pdf_token_index,
+                                head_spec,
+                                expected_len,
+                                "head",
+                                mid_specs,
+                                require_unique=True,
+                            )
+                    else:
+                        span = _find_span_from_anchor(
+                            pdf_token_index,
+                            head_spec,
+                            expected_len,
+                            "head",
+                            mid_specs,
+                        )
+                    if span:
+                        break
+                if span is None:
+                    for tail_spec in tail_specs:
+                        if mid_specs:
+                            span = _find_span_from_anchor(
+                                pdf_token_index,
+                                tail_spec,
+                                expected_len,
+                                "tail",
+                                mid_specs,
+                                require_mid=True,
+                            )
+                            if span is None:
+                                span = _find_span_from_anchor(
+                                    pdf_token_index,
+                                    tail_spec,
+                                    expected_len,
+                                    "tail",
+                                    mid_specs,
+                                    require_unique=True,
+                                )
+                        else:
+                            span = _find_span_from_anchor(
+                                pdf_token_index,
+                                tail_spec,
+                                expected_len,
+                                "tail",
+                                mid_specs,
+                            )
+                        if span:
+                            break
+                if span:
+                    definition = _extract_with_trailing_punct(
+                        pdf_token_index.doc_text,
+                        span[0],
+                        span[1],
+                    )
+                    hydrated_from_pdf += 1
+                    hydrated_from_anchor += 1
+
+        if not definition:
+            missing_defs += 1
+            missing_def_rows.append(
+                {
+                    "paper_id": paper_id,
+                    "concept": row.get("concept", ""),
+                    "reason": "missing_definition",
+                },
+            )
+
+        if not context and pdf_path is not None and pdf_token_index:
+            spec = _select_hash_specs(row, "context")
+            if spec:
+                span = pdf_token_index.find_span_by_hash(*spec)
+                if span:
+                    context = _extract_with_trailing_punct(
+                        pdf_token_index.doc_text,
+                        span[0],
+                        span[1],
+                    )
+                    hydrated_from_pdf += 1
+            if not context:
+                head_specs = _select_anchor_spec_list(
+                    row,
+                    "context",
+                    "head",
+                )
+                mid_specs = _select_anchor_spec_list(
+                    row,
+                    "context",
+                    "mid",
+                )
+                tail_specs = _select_anchor_spec_list(
+                    row,
+                    "context",
+                    "tail",
+                )
+                expected_len = int(row.get("context_token_count") or 0)
+                for head_spec in head_specs or [None]:
+                    for tail_spec in tail_specs or [None]:
+                        if head_spec is None or tail_spec is None:
+                            continue
+                        span = _find_span_by_anchors(
+                            pdf_token_index,
+                            head_spec,
+                            tail_spec,
+                            expected_len,
+                            mid_specs,
+                            require_mid=True,
+                        )
+                        if span is None:
+                            span = _find_span_by_anchors(
+                                pdf_token_index,
+                                head_spec,
+                                tail_spec,
+                                expected_len,
+                            )
+                        if span:
+                            context = _extract_with_trailing_punct(
+                                pdf_token_index.doc_text,
+                                span[0],
+                                span[1],
+                            )
+                            hydrated_from_pdf += 1
+                            hydrated_from_anchor += 1
+                            break
+                    if context:
+                        break
+            if not context:
+                head_specs = _select_anchor_spec_list(
+                    row,
+                    "context",
+                    "head",
+                )
+                mid_specs = _select_anchor_spec_list(
+                    row,
+                    "context",
+                    "mid",
+                )
+                tail_specs = _select_anchor_spec_list(
+                    row,
+                    "context",
+                    "tail",
+                )
+                expected_len = int(row.get("context_token_count") or 0)
+                span = None
+                for head_spec in head_specs:
+                    if mid_specs:
+                        span = _find_span_from_anchor(
+                            pdf_token_index,
+                            head_spec,
+                            expected_len,
+                            "head",
+                            mid_specs,
+                            require_mid=True,
+                        )
+                        if span is None:
+                            span = _find_span_from_anchor(
+                                pdf_token_index,
+                                head_spec,
+                                expected_len,
+                                "head",
+                                mid_specs,
+                                require_unique=True,
+                            )
+                    else:
+                        span = _find_span_from_anchor(
+                            pdf_token_index,
+                            head_spec,
+                            expected_len,
+                            "head",
+                            mid_specs,
+                        )
+                    if span:
+                        break
+                if span is None:
+                    for tail_spec in tail_specs:
+                        if mid_specs:
+                            span = _find_span_from_anchor(
+                                pdf_token_index,
+                                tail_spec,
+                                expected_len,
+                                "tail",
+                                mid_specs,
+                                require_mid=True,
+                            )
+                            if span is None:
+                                span = _find_span_from_anchor(
+                                    pdf_token_index,
+                                    tail_spec,
+                                    expected_len,
+                                    "tail",
+                                    mid_specs,
+                                    require_unique=True,
+                                )
+                        else:
+                            span = _find_span_from_anchor(
+                                pdf_token_index,
+                                tail_spec,
+                                expected_len,
+                                "tail",
+                                mid_specs,
+                            )
+                        if span:
+                            break
+                if span:
+                    context = _extract_with_trailing_punct(
+                        pdf_token_index.doc_text,
+                        span[0],
+                        span[1],
+                    )
+                    hydrated_from_pdf += 1
+                    hydrated_from_anchor += 1
+
+        if not context:
+            missing_ctxs += 1
+            missing_ctx_rows.append(
+                {
+                    "paper_id": paper_id,
+                    "concept": row.get("concept", ""),
+                    "reason": "missing_context",
+                },
+            )
+
+        def_preserve_lines = _row_flag(
+            row,
+            "definition_preserve_linebreaks",
+        )
+        ctx_preserve_lines = _row_flag(
+            row,
+            "context_preserve_linebreaks",
+        )
+        def_preserve_hyph = _row_flag(
+            row,
+            "definition_preserve_hyphenation",
+        )
+        ctx_preserve_hyph = _row_flag(
+            row,
+            "context_preserve_hyphenation",
+        )
+        def_keep_bracket = _row_flag(
+            row,
+            "definition_has_bracket_citation",
+            True,
+        )
+        def_keep_paren = _row_flag(
+            row,
+            "definition_has_paren_citation",
+            True,
+        )
+        def_split_letter_digit = not _row_flag(
+            row,
+            "definition_has_letter_digit",
+        )
+        ctx_keep_bracket = _row_flag(
+            row,
+            "context_has_bracket_citation",
+            True,
+        )
+        ctx_keep_paren = _row_flag(
+            row,
+            "context_has_paren_citation",
+            True,
+        )
+        ctx_split_letter_digit = not _row_flag(
+            row,
+            "context_has_letter_digit",
+        )
+
+        output_rows.append(
+            {
+                "paper_id": paper_id,
+                "paper_title": row.get("paper_title", ""),
+                "paper_doi": doi,
+                "paper_arxiv": arxiv,
+                "concept": row.get("concept", ""),
+                "definition": _ensure_trailing_punct(
+                    _postprocess_text(
+                        definition,
+                        int(row.get("definition_token_count") or 0),
+                        def_preserve_lines,
+                        def_preserve_hyph,
+                        def_keep_bracket,
+                        def_keep_paren,
+                        def_split_letter_digit,
+                    ),
+                    row.get("definition_end_punct", ""),
+                ),
+                "context": _ensure_trailing_punct(
+                    _postprocess_text(
+                        context,
+                        int(row.get("context_token_count") or 0),
+                        ctx_preserve_lines,
+                        ctx_preserve_hyph,
+                        ctx_keep_bracket,
+                        ctx_keep_paren,
+                        ctx_split_letter_digit,
+                    ),
+                    row.get("context_end_punct", ""),
+                ),
+                "definition_type": row.get("definition_type", ""),
+                "source_file": row.get("source_file", ""),
+                "is_out_of_domain": row.get("is_out_of_domain", ""),
+            },
+        )
+
+    args.output_csv.parent.mkdir(parents=True, exist_ok=True)
+    with args.output_csv.open("w", encoding="utf-8", newline="") as handle:
+        fieldnames = [
+            "paper_id",
+            "paper_title",
+            "paper_doi",
+            "paper_arxiv",
+            "concept",
+            "definition",
+            "context",
+            "definition_type",
+            "source_file",
+            "is_out_of_domain",
+        ]
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in output_rows:
+            writer.writerow(row)
+
+    print(f"Wrote hydrated CSV to {args.output_csv}")
+    print(f"Missing TEI for {len(missing_papers)} papers")
+    print(f"Missing definition spans: {missing_defs}")
+    print(f"Missing context spans: {missing_ctxs}")
+    print(
+        "Hydrated from PDF fallback: "
+        f"{hydrated_from_pdf} (anchors used: {hydrated_from_anchor})",
+    )
+    if args.report is not None:
+        report_lines = []
+        if missing_papers:
+            report_lines.append("Missing papers:")
+            for paper_id in sorted(missing_papers):
+                report_lines.append(f"- {paper_id}")
+            report_lines.append("")
+        if pdf_hash_mismatches:
+            report_lines.append(
+                "PDF hash mismatches (filename matched, hash did not):",
+            )
+            for item in pdf_hash_mismatches:
+                report_lines.append(
+                    f"- {item['paper_id']} | {item['pdf']}",
+                )
+            report_lines.append(
+                "Note: rerun with --allow-pdf-hash-mismatch to continue with these PDFs.",
+            )
+            report_lines.append("")
+        report_lines.append(f"Missing definition spans: {missing_defs}")
+        report_lines.append(f"Missing context spans: {missing_ctxs}")
+        if missing_def_rows:
+            report_lines.append("")
+            report_lines.append("Missing definitions (paper_id | concept):")
+            for item in missing_def_rows:
+                report_lines.append(
+                    f"- {item['paper_id']} | {item['concept']}",
+                )
+        if missing_ctx_rows:
+            report_lines.append("")
+            report_lines.append("Missing contexts (paper_id | concept):")
+            for item in missing_ctx_rows:
+                report_lines.append(
+                    f"- {item['paper_id']} | {item['concept']}",
+                )
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text(
+            "\n".join(report_lines) + "\n",
+            encoding="utf-8",
+        )
+        print(f"Wrote report to {args.report}")
+    if args.require_complete and (missing_defs or missing_ctxs):
+        raise SystemExit(
+            "Hydration incomplete: "
+            f"{missing_defs} definitions, {missing_ctxs} contexts missing.",
+        )
+
+
+if __name__ == "__main__":
+    main()

scripts/list_defextra_pdfs.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import re
+from pathlib import Path
+from typing import Dict, Iterable, List
+
+import sys
+
+try:
+    from scripts.defextra_markers import (
+        normalize_paper_id,
+        normalize_arxiv,
+        normalize_doi,
+    )
+    from scripts.defextra_pdf_aliases import candidate_pdf_aliases
+except ModuleNotFoundError as exc:
+    if exc.name != "scripts":
+        raise
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    if str(PROJECT_ROOT) not in sys.path:
+        sys.path.insert(0, str(PROJECT_ROOT))
+    from scripts.defextra_markers import (
+        normalize_paper_id,
+        normalize_arxiv,
+        normalize_doi,
+    )
+    from scripts.defextra_pdf_aliases import candidate_pdf_aliases
+
+
+S2_ID_RE = re.compile(r"^[0-9a-f]{40}$", re.IGNORECASE)
+
+
+def _safe_join(values: Iterable[str]) -> str:
+    return ";".join(v for v in values if v)
+
+
+def _semanticscholar_url(paper_id: str) -> str:
+    if S2_ID_RE.match(paper_id):
+        return f"https://www.semanticscholar.org/paper/{paper_id}"
+    return ""
+
+
+def _acl_url(paper_id: str) -> str:
+    if paper_id.startswith("https://aclanthology.org/"):
+        return paper_id
+    if re.match(r"^[0-9]{4}\\.[a-z-]+\\.[0-9]+$", paper_id, re.IGNORECASE):
+        return f"https://aclanthology.org/{paper_id}"
+    return ""
+
+
+def _doi_url(doi: str, paper_id: str) -> str:
+    if doi:
+        return f"https://doi.org/{normalize_doi(doi)}"
+    if paper_id.startswith("10."):
+        return f"https://doi.org/{normalize_doi(paper_id)}"
+    if "doi.org/" in paper_id:
+        return f"https://doi.org/{normalize_doi(paper_id)}"
+    return ""
+
+
+def _arxiv_url(arxiv: str, paper_id: str) -> str:
+    if arxiv:
+        return f"https://arxiv.org/abs/{normalize_arxiv(arxiv)}"
+    match = re.search(r"arxiv\\.org/(abs|pdf)/([^?#]+)", paper_id)
+    if match:
+        return f"https://arxiv.org/abs/{match.group(2).replace('.pdf', '')}"
+    return ""
+
+
+def _collect_papers(rows: List[Dict[str, str]]) -> Dict[str, Dict[str, str]]:
+    papers: Dict[str, Dict[str, str]] = {}
+    for row in rows:
+        paper_id = (row.get("paper_id") or "").strip()
+        if not paper_id:
+            continue
+        record = papers.setdefault(
+            paper_id,
+            {
+                "paper_id": paper_id,
+                "paper_title": (row.get("paper_title") or "").strip(),
+                "paper_doi": (row.get("paper_doi") or "").strip(),
+                "paper_arxiv": (row.get("paper_arxiv") or "").strip(),
+            },
+        )
+        if not record["paper_title"] and row.get("paper_title"):
+            record["paper_title"] = row.get("paper_title", "").strip()
+        if not record["paper_doi"] and row.get("paper_doi"):
+            record["paper_doi"] = row.get("paper_doi", "").strip()
+        if not record["paper_arxiv"] and row.get("paper_arxiv"):
+            record["paper_arxiv"] = row.get("paper_arxiv", "").strip()
+    return papers
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description=(
+            "List required PDFs for DefExtra and generate helper links."
+        ),
+    )
+    parser.add_argument(
+        "--legal-csv",
+        type=Path,
+        default=Path("data/defextra_legal.csv"),
+        help="Path to DefExtra legal CSV.",
+    )
+    parser.add_argument(
+        "--output-csv",
+        type=Path,
+        default=None,
+        help="Optional output CSV path.",
+    )
+    parser.add_argument(
+        "--output-md",
+        type=Path,
+        default=None,
+        help="Optional output Markdown list path.",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=10,
+        help="How many entries to print to stdout (0 = none).",
+    )
+    args = parser.parse_args()
+
+    if not args.legal_csv.exists():
+        raise SystemExit(f"Legal CSV not found: {args.legal_csv}")
+
+    with args.legal_csv.open("r", encoding="utf-8", newline="") as handle:
+        rows = list(csv.DictReader(handle))
+
+    papers = _collect_papers(rows)
+    output_rows: List[Dict[str, str]] = []
+
+    for paper_id, record in sorted(papers.items()):
+        doi = record.get("paper_doi", "")
+        arxiv = record.get("paper_arxiv", "")
+        normalized_id = normalize_paper_id(paper_id)
+        aliases = candidate_pdf_aliases(paper_id, doi, arxiv)
+        output_rows.append(
+            {
+                "paper_id": paper_id,
+                "normalized_id": normalized_id,
+                "paper_title": record.get("paper_title", ""),
+                "paper_doi": doi,
+                "paper_arxiv": arxiv,
+                "preferred_pdf_name": f"{normalized_id}.pdf",
+                "alias_pdf_names": _safe_join(
+                    f"{alias}.pdf" for alias in aliases
+                ),
+                "url_semanticscholar": _semanticscholar_url(paper_id),
+                "url_doi": _doi_url(doi, paper_id),
+                "url_arxiv": _arxiv_url(arxiv, paper_id),
+                "url_acl": _acl_url(paper_id),
+            },
+        )
+
+    if args.output_csv:
+        args.output_csv.parent.mkdir(parents=True, exist_ok=True)
+        with args.output_csv.open("w", encoding="utf-8", newline="") as handle:
+            fieldnames = list(output_rows[0].keys()) if output_rows else []
+            writer = csv.DictWriter(handle, fieldnames=fieldnames)
+            writer.writeheader()
+            for row in output_rows:
+                writer.writerow(row)
+        print(f"Wrote {len(output_rows)} rows to {args.output_csv}")
+
+    if args.output_md:
+        lines = ["# DefExtra required PDFs", ""]
+        for row in output_rows:
+            line = f"- {row['paper_id']} — {row['paper_title']}"
+            links = [
+                row["url_semanticscholar"],
+                row["url_doi"],
+                row["url_arxiv"],
+                row["url_acl"],
+            ]
+            links = [link for link in links if link]
+            if links:
+                line += " (" + ", ".join(links) + ")"
+            lines.append(line)
+        args.output_md.parent.mkdir(parents=True, exist_ok=True)
+        args.output_md.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        print(f"Wrote {len(output_rows)} rows to {args.output_md}")
+
+    if args.limit > 0:
+        for row in output_rows[: args.limit]:
+            print(
+                f"{row['paper_id']} | {row['preferred_pdf_name']} | "
+                f"{row['url_semanticscholar'] or row['url_doi'] or row['url_arxiv'] or row['url_acl']}",
+            )
+
+
+if __name__ == "__main__":
+    main()

scripts/pdf_to_grobid.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env env python3
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+try:
+    from grobid_client.grobid_client import GrobidClient
+except ImportError:
+    print("Error: grobid-client-python is not installed.")
+    print("Please install it with: pip install grobid-client-python")
+    sys.exit(1)
+
+
+def process_pdfs_with_grobid(
+    input_folder: str,
+    output_folder: str,
+    config_path: str | None = None,
+):
+    """
+    Process all PDF files in the input folder with GROBID and save TEI XML to output folder.
+
+    Args:
+        input_folder: Path to folder containing PDF files
+        output_folder: Path to folder where XML files will be saved
+        config_path: Path to GROBID client configuration file
+    """
+    # Validate input folder
+    if not os.path.exists(input_folder):
+        print(f"Error: Input folder '{input_folder}' does not exist.")
+        sys.exit(1)
+
+    if not os.path.isdir(input_folder):
+        print(f"Error: '{input_folder}' is not a directory.")
+        sys.exit(1)
+
+    # Create output folder if it doesn't exist
+    os.makedirs(output_folder, exist_ok=True)
+
+    # Find all PDF files in input folder
+    pdf_files = list(Path(input_folder).glob("*.pdf"))
+    pdf_files.extend(list(Path(input_folder).glob("*.PDF")))
+    valid_pdf_files = []
+    for pdf_file in pdf_files:
+        if not pdf_file.exists():
+            print(f"Warning: skipping missing/broken PDF path: {pdf_file}")
+            continue
+        valid_pdf_files.append(pdf_file)
+    pdf_files = valid_pdf_files
+
+    if not pdf_files:
+        print(f"No PDF files found in '{input_folder}'")
+        return
+
+    print(f"Found {len(pdf_files)} PDF file(s) to process")
+
+    # Initialize GROBID client
+    temp_config_path = None
+    try:
+        if config_path and os.path.exists(config_path):
+            client = GrobidClient(config_path=config_path)
+        else:
+            default_config = {
+                "grobid_server": "http://localhost:8070",
+                "batch_size": 1000,
+                "sleep_time": 5,
+                "timeout": 60,
+            }
+            temp_handle = tempfile.NamedTemporaryFile(
+                mode="w",
+                suffix=".json",
+                delete=False,
+            )
+            json.dump(default_config, temp_handle)
+            temp_handle.close()
+            temp_config_path = temp_handle.name
+            client = GrobidClient(config_path=temp_config_path)
+    except Exception as e:
+        print(f"Error initializing GROBID client: {e}")
+        if config_path:
+            print(f"Make sure the config file exists at '{config_path}'")
+        else:
+            print("Provide --config config.json if required.")
+        sys.exit(1)
+
+    # Create temporary directories for processing
+    temp_input_dir = tempfile.mkdtemp()
+    temp_output_dir = tempfile.mkdtemp()
+
+    try:
+        # Copy PDFs to temporary input directory
+        print("\nPreparing files for processing...")
+        for pdf_file in pdf_files:
+            pdf_filename = os.path.basename(pdf_file)
+            temp_pdf_path = os.path.join(temp_input_dir, pdf_filename)
+            shutil.copy2(pdf_file, temp_pdf_path)
+            print(f"  - {pdf_filename}")
+
+        # Process with GROBID
+        print(f"\nProcessing {len(pdf_files)} PDF(s) with GROBID...")
+        print(
+            "This may take a while depending on the number and size of files...",
+        )
+
+        client.process(
+            "processFulltextDocument",
+            temp_input_dir,
+            output=temp_output_dir,
+        )
+
+        # Copy results to output folder
+        print("\nSaving results...")
+        processed_count = 0
+        failed_count = 0
+
+        for pdf_file in pdf_files:
+            pdf_filename = os.path.basename(pdf_file)
+
+            # Expected output filename from GROBID
+            output_filename = (
+                f"{os.path.splitext(pdf_filename)[0]}.grobid.tei.xml"
+            )
+            temp_output_path = os.path.join(temp_output_dir, output_filename)
+
+            if os.path.exists(temp_output_path):
+                # Copy to final output directory
+                final_output_path = os.path.join(
+                    output_folder,
+                    output_filename,
+                )
+                shutil.copy2(temp_output_path, final_output_path)
+                print(f"  ✓ {pdf_filename} -> {output_filename}")
+                processed_count += 1
+            else:
+                print(
+                    f"  ✗ {pdf_filename} - Processing failed (no output generated)",
+                )
+                failed_count += 1
+
+        # Summary
+        print(f"\n{'=' * 60}")
+        print("Processing complete!")
+        print(f"Successfully processed: {processed_count}/{len(pdf_files)}")
+        if failed_count > 0:
+            print(f"Failed: {failed_count}/{len(pdf_files)}")
+        print(f"Output saved to: {os.path.abspath(output_folder)}")
+        print(f"{'=' * 60}")
+
+    except Exception as e:
+        print(f"\nError during processing: {e}")
+        sys.exit(1)
+
+    finally:
+        # Clean up temporary directories
+        shutil.rmtree(temp_input_dir, ignore_errors=True)
+        shutil.rmtree(temp_output_dir, ignore_errors=True)
+        if temp_config_path and os.path.exists(temp_config_path):
+            try:
+                os.remove(temp_config_path)
+            except OSError:
+                pass
+
+
+def main():
+    """Main entry point for the script."""
+    parser = argparse.ArgumentParser(
+        description="Process PDF files with GROBID and extract TEI XML",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python grobid_batch_processor.py --input_path ./pdfs --output_path ./output
+  python grobid_batch_processor.py --input_path ./pdfs --output_path ./output --config ./my_config.json
+
+Note: Make sure GROBID server is running before executing this script.
+See: https://grobid.readthedocs.io/en/latest/Grobid-service/
+        """,
+    )
+
+    parser.add_argument(
+        "--input_folder",
+        help="Path to folder containing PDF files to process",
+    )
+
+    parser.add_argument(
+        "--output_folder",
+        help="Path to folder where XML output files will be saved",
+    )
+
+    parser.add_argument(
+        "--config",
+        default=None,
+        help="Path to GROBID client configuration file (optional).",
+    )
+
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("GROBID Batch PDF Processor")
+    print("=" * 60)
+
+    process_pdfs_with_grobid(
+        args.input_folder,
+        args.output_folder,
+        args.config,
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/prepare_defextra_legal.py

@@ -0,0 +1,877 @@
+from __future__ import annotations
+
+# ruff: noqa: E402
+
+import argparse
+import csv
+import re
+import sys
+from pathlib import Path
+from typing import Dict, Optional
+
+try:
+    from scripts.defextra_markers import (
+        ANCHOR_WINDOW,
+        ANCHOR_WINDOW_ALT,
+        DocIndex,
+        HASH_VERSION,
+        TokenIndex,
+        build_tei_index,
+        hash_token_sequence,
+        tokenize_text,
+        normalize_paper_id,
+    )
+except ModuleNotFoundError as exc:
+    if exc.name != "scripts":
+        raise
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    if str(PROJECT_ROOT) not in sys.path:
+        sys.path.insert(0, str(PROJECT_ROOT))
+    from scripts.defextra_markers import (
+        ANCHOR_WINDOW,
+        ANCHOR_WINDOW_ALT,
+        DocIndex,
+        HASH_VERSION,
+        TokenIndex,
+        build_tei_index,
+        hash_token_sequence,
+        tokenize_text,
+        normalize_paper_id,
+    )
+
+TRAILING_PUNCT = {".", ",", ";", ":", "?", "!"}
+TRAILING_QUOTES = {"'", '"', "”", "’", ")", "]"}
+CITATION_BRACKET_RE = re.compile(r"\[[0-9][0-9,;\s\-–]*\]")
+CITATION_PAREN_RE = re.compile(r"\([^)]*\d{4}[^)]*\)")
+
+
+def _extract_end_punct(text: str) -> str:
+    trimmed = text.rstrip()
+    if not trimmed:
+        return ""
+    i = len(trimmed) - 1
+    while i >= 0 and trimmed[i] in TRAILING_QUOTES:
+        i -= 1
+    if i >= 0 and trimmed[i] in TRAILING_PUNCT:
+        return trimmed[i]
+    return ""
+
+
+def _spec(
+    count: str,
+    hash64: str,
+    sha: str,
+) -> Optional[tuple[int, int, str]]:
+    if not count or not hash64 or not sha:
+        return None
+    try:
+        return int(count), int(hash64), sha
+    except ValueError:
+        return None
+
+
+def _build_mid_candidates(
+    token_index: TokenIndex,
+    mid_specs: list[tuple[int, int, str]],
+) -> list[tuple[int, int]]:
+    if not mid_specs:
+        return []
+    candidates: list[tuple[int, int]] = []
+    for spec in mid_specs:
+        for position in token_index.find_token_positions_by_hash(*spec):
+            candidates.append((position, spec[0]))
+    return candidates
+
+
+def _span_has_mid(
+    mid_candidates: list[tuple[int, int]],
+    start_idx: int,
+    end_idx: int,
+) -> bool:
+    for mid_start, mid_len in mid_candidates:
+        mid_end = mid_start + mid_len - 1
+        if mid_start >= start_idx and mid_end <= end_idx:
+            return True
+    return False
+
+
+def _find_span_by_anchors(
+    token_index: TokenIndex,
+    head_spec: Optional[tuple[int, int, str]],
+    tail_spec: Optional[tuple[int, int, str]],
+    expected_len: int,
+    mid_specs: Optional[list[tuple[int, int, str]]] = None,
+) -> Optional[tuple[int, int]]:
+    if head_spec is None or tail_spec is None or expected_len <= 0:
+        return None
+    head_positions = token_index.find_token_positions_by_hash(*head_spec)
+    tail_positions = token_index.find_token_positions_by_hash(*tail_spec)
+    if not head_positions or not tail_positions:
+        return None
+    mid_candidates = _build_mid_candidates(token_index, mid_specs or [])
+    best = None
+    best_diff = None
+    tol = max(5, int(expected_len * 0.3))
+    min_len = max(1, expected_len // 2)
+    max_len = expected_len * 3
+    for head_start in head_positions:
+        head_end = head_start + head_spec[0] - 1
+        for tail_start in tail_positions:
+            tail_end = tail_start + tail_spec[0] - 1
+            if tail_end < head_end:
+                continue
+            if mid_candidates and not _span_has_mid(
+                mid_candidates,
+                head_start,
+                tail_end,
+            ):
+                continue
+            length = tail_end - head_start + 1
+            if length < min_len or length > max_len:
+                continue
+            if length < expected_len - tol or length > expected_len + tol:
+                continue
+            diff = abs(length - expected_len)
+            if best_diff is None or diff < best_diff:
+                best_diff = diff
+                best = (head_start, tail_end)
+    if best is None:
+        return None
+    start_char = token_index.spans[best[0]][0]
+    end_char = token_index.spans[best[1]][1]
+    return start_char, end_char
+
+
+def _find_span_from_anchor(
+    token_index: TokenIndex,
+    anchor_spec: Optional[tuple[int, int, str]],
+    expected_len: int,
+    position: str,
+    mid_specs: Optional[list[tuple[int, int, str]]] = None,
+) -> Optional[tuple[int, int]]:
+    if anchor_spec is None or expected_len <= 0:
+        return None
+    positions = token_index.find_token_positions_by_hash(*anchor_spec)
+    if not positions:
+        return None
+    mid_candidates = _build_mid_candidates(token_index, mid_specs or [])
+    if position == "tail":
+        positions = list(reversed(positions))
+    for anchor_start in positions:
+        if position == "head":
+            start_idx = anchor_start
+            end_idx = anchor_start + expected_len - 1
+        else:
+            anchor_end = anchor_start + anchor_spec[0] - 1
+            end_idx = anchor_end
+            start_idx = end_idx - expected_len + 1
+        if start_idx < 0 or end_idx >= len(token_index.tokens):
+            continue
+        if mid_candidates and not _span_has_mid(
+            mid_candidates,
+            start_idx,
+            end_idx,
+        ):
+            continue
+        start_char = token_index.spans[start_idx][0]
+        end_char = token_index.spans[end_idx][1]
+        return start_char, end_char
+    return None
+
+
+def _candidate_ids(paper_id: str, doi: str, arxiv: str) -> list[str]:
+    candidates = [paper_id, normalize_paper_id(paper_id)]
+    if doi:
+        candidates.append(doi)
+    if arxiv:
+        candidates.append(arxiv)
+    seen = set()
+    ordered = []
+    for item in candidates:
+        value = item.strip()
+        if value and value not in seen:
+            seen.add(value)
+            ordered.append(value)
+    return ordered
+
+
+def _resolve_tei_path(
+    paper_id: str,
+    doi: str,
+    arxiv: str,
+    tei_index: Dict[str, Path],
+) -> Optional[Path]:
+    for candidate in _candidate_ids(paper_id, doi, arxiv):
+        if candidate in tei_index:
+            return tei_index[candidate]
+        if candidate.startswith("paper_"):
+            stripped = candidate[len("paper_") :]
+            if stripped in tei_index:
+                return tei_index[stripped]
+    return None
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Build legal DefExtra CSV with GROBID markers.",
+    )
+    parser.add_argument(
+        "--input-csv",
+        type=Path,
+        default=Path("results/paper_results/defextra_hf.csv"),
+        help="Source DefExtra CSV (contains excerpts).",
+    )
+    parser.add_argument(
+        "--output-csv",
+        type=Path,
+        default=Path("results/paper_results/defextra_legal.csv"),
+        help="Output legal DefExtra CSV (no excerpts).",
+    )
+    parser.add_argument(
+        "--tei-dir",
+        type=Path,
+        nargs="+",
+        default=[
+            Path("ManualPDFsGROBID/manual_pdfs_grobid"),
+            Path("ManualPDFsGROBID/new_grobid"),
+        ],
+        help="Directories with GROBID TEI files.",
+    )
+    parser.add_argument(
+        "--report",
+        type=Path,
+        default=None,
+        help="Optional report path for missing TEI spans.",
+    )
+    args = parser.parse_args()
+
+    if not args.input_csv.exists():
+        raise SystemExit(f"Input CSV not found: {args.input_csv}")
+
+    tei_index = build_tei_index(args.tei_dir)
+    doc_cache: Dict[str, Optional[DocIndex]] = {}
+    token_cache: Dict[str, Optional[TokenIndex]] = {}
+
+    rows = []
+    with args.input_csv.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        for row in reader:
+            rows.append(row)
+
+    output_rows = []
+    missing_tei = 0
+    missing_def = 0
+    missing_ctx = 0
+    missing_def_rows: list[dict] = []
+    missing_ctx_rows: list[dict] = []
+    def_hash_available = 0
+    ctx_hash_available = 0
+    def_anchor_available = 0
+    ctx_anchor_available = 0
+
+    for row in rows:
+        paper_id = (row.get("paper_id") or "").strip()
+        doi = (row.get("paper_doi") or "").strip()
+        arxiv = (row.get("paper_arxiv") or "").strip()
+        definition = row.get("definition") or ""
+        context = row.get("context") or ""
+
+        if paper_id not in doc_cache:
+            tei_path = _resolve_tei_path(paper_id, doi, arxiv, tei_index)
+            if tei_path is None:
+                doc_cache[paper_id] = None
+                token_cache[paper_id] = None
+            else:
+                doc_index = DocIndex.from_tei(tei_path)
+                doc_cache[paper_id] = doc_index
+                token_cache[paper_id] = TokenIndex.from_text(
+                    doc_index.doc_text,
+                )
+
+        doc_index = doc_cache.get(paper_id)
+        def_start = def_end = ctx_start = ctx_end = ""
+        def_match = ctx_match = "missing"
+        def_hash64 = def_sha = def_tok_len = ""
+        ctx_hash64 = ctx_sha = ctx_tok_len = ""
+        def_head_hash64 = def_head_sha = def_head_len = ""
+        def_tail_hash64 = def_tail_sha = def_tail_len = ""
+        def_mid_hash64 = def_mid_sha = def_mid_len = ""
+        def_head_alt_hash64 = def_head_alt_sha = def_head_alt_len = ""
+        def_tail_alt_hash64 = def_tail_alt_sha = def_tail_alt_len = ""
+        def_mid_alt_hash64 = def_mid_alt_sha = def_mid_alt_len = ""
+        ctx_head_hash64 = ctx_head_sha = ctx_head_len = ""
+        ctx_tail_hash64 = ctx_tail_sha = ctx_tail_len = ""
+        ctx_mid_hash64 = ctx_mid_sha = ctx_mid_len = ""
+        ctx_head_alt_hash64 = ctx_head_alt_sha = ctx_head_alt_len = ""
+        ctx_tail_alt_hash64 = ctx_tail_alt_sha = ctx_tail_alt_len = ""
+        ctx_mid_alt_hash64 = ctx_mid_alt_sha = ctx_mid_alt_len = ""
+        def_anchor_has = False
+        ctx_anchor_has = False
+        def_preserve_linebreaks = "true" if "\n" in definition else "false"
+        ctx_preserve_linebreaks = "true" if "\n" in context else "false"
+        def_preserve_hyphenation = (
+            "true"
+            if re.search(r"[A-Za-z]-\s+[A-Za-z]", definition)
+            else "false"
+        )
+        ctx_preserve_hyphenation = (
+            "true" if re.search(r"[A-Za-z]-\s+[A-Za-z]", context) else "false"
+        )
+        def_has_bracket_citation = (
+            "true" if CITATION_BRACKET_RE.search(definition) else "false"
+        )
+        def_has_paren_citation = (
+            "true" if CITATION_PAREN_RE.search(definition) else "false"
+        )
+        def_has_letter_digit = (
+            "true" if re.search(r"[A-Za-z][0-9]", definition) else "false"
+        )
+        ctx_has_bracket_citation = (
+            "true" if CITATION_BRACKET_RE.search(context) else "false"
+        )
+        ctx_has_paren_citation = (
+            "true" if CITATION_PAREN_RE.search(context) else "false"
+        )
+        ctx_has_letter_digit = (
+            "true" if re.search(r"[A-Za-z][0-9]", context) else "false"
+        )
+        def_end_punct = _extract_end_punct(definition)
+        ctx_end_punct = _extract_end_punct(context)
+
+        def_tokens, _ = tokenize_text(definition, return_spans=False)
+        if def_tokens:
+            h64, sha, tok_len = hash_token_sequence(def_tokens)
+            def_hash64 = str(h64)
+            def_sha = sha
+            def_tok_len = str(tok_len)
+            def_hash_available += 1
+            if tok_len >= ANCHOR_WINDOW:
+                h64, sha, tok_len = hash_token_sequence(
+                    def_tokens[:ANCHOR_WINDOW],
+                )
+                def_head_hash64 = str(h64)
+                def_head_sha = sha
+                def_head_len = str(tok_len)
+                h64, sha, tok_len = hash_token_sequence(
+                    def_tokens[-ANCHOR_WINDOW:],
+                )
+                def_tail_hash64 = str(h64)
+                def_tail_sha = sha
+                def_tail_len = str(tok_len)
+                mid_start = max(0, (len(def_tokens) - ANCHOR_WINDOW) // 2)
+                h64, sha, tok_len = hash_token_sequence(
+                    def_tokens[mid_start : mid_start + ANCHOR_WINDOW],
+                )
+                def_mid_hash64 = str(h64)
+                def_mid_sha = sha
+                def_mid_len = str(tok_len)
+                def_anchor_has = True
+            if tok_len >= 2:
+                alt_window = (
+                    ANCHOR_WINDOW_ALT
+                    if tok_len >= ANCHOR_WINDOW_ALT
+                    else max(2, tok_len - 1)
+                )
+                h64, sha, tok_len = hash_token_sequence(
+                    def_tokens[:alt_window],
+                )
+                def_head_alt_hash64 = str(h64)
+                def_head_alt_sha = sha
+                def_head_alt_len = str(tok_len)
+                h64, sha, tok_len = hash_token_sequence(
+                    def_tokens[-alt_window:],
+                )
+                def_tail_alt_hash64 = str(h64)
+                def_tail_alt_sha = sha
+                def_tail_alt_len = str(tok_len)
+                mid_start = max(0, (len(def_tokens) - alt_window) // 2)
+                h64, sha, tok_len = hash_token_sequence(
+                    def_tokens[mid_start : mid_start + alt_window],
+                )
+                def_mid_alt_hash64 = str(h64)
+                def_mid_alt_sha = sha
+                def_mid_alt_len = str(tok_len)
+                def_anchor_has = True
+
+        ctx_tokens, _ = tokenize_text(context, return_spans=False)
+        if ctx_tokens:
+            h64, sha, tok_len = hash_token_sequence(ctx_tokens)
+            ctx_hash64 = str(h64)
+            ctx_sha = sha
+            ctx_tok_len = str(tok_len)
+            ctx_hash_available += 1
+            if tok_len >= ANCHOR_WINDOW:
+                h64, sha, tok_len = hash_token_sequence(
+                    ctx_tokens[:ANCHOR_WINDOW],
+                )
+                ctx_head_hash64 = str(h64)
+                ctx_head_sha = sha
+                ctx_head_len = str(tok_len)
+                h64, sha, tok_len = hash_token_sequence(
+                    ctx_tokens[-ANCHOR_WINDOW:],
+                )
+                ctx_tail_hash64 = str(h64)
+                ctx_tail_sha = sha
+                ctx_tail_len = str(tok_len)
+                mid_start = max(0, (len(ctx_tokens) - ANCHOR_WINDOW) // 2)
+                h64, sha, tok_len = hash_token_sequence(
+                    ctx_tokens[mid_start : mid_start + ANCHOR_WINDOW],
+                )
+                ctx_mid_hash64 = str(h64)
+                ctx_mid_sha = sha
+                ctx_mid_len = str(tok_len)
+                ctx_anchor_has = True
+            if tok_len >= 2:
+                alt_window = (
+                    ANCHOR_WINDOW_ALT
+                    if tok_len >= ANCHOR_WINDOW_ALT
+                    else max(2, tok_len - 1)
+                )
+                h64, sha, tok_len = hash_token_sequence(
+                    ctx_tokens[:alt_window],
+                )
+                ctx_head_alt_hash64 = str(h64)
+                ctx_head_alt_sha = sha
+                ctx_head_alt_len = str(tok_len)
+                h64, sha, tok_len = hash_token_sequence(
+                    ctx_tokens[-alt_window:],
+                )
+                ctx_tail_alt_hash64 = str(h64)
+                ctx_tail_alt_sha = sha
+                ctx_tail_alt_len = str(tok_len)
+                mid_start = max(0, (len(ctx_tokens) - alt_window) // 2)
+                h64, sha, tok_len = hash_token_sequence(
+                    ctx_tokens[mid_start : mid_start + alt_window],
+                )
+                ctx_mid_alt_hash64 = str(h64)
+                ctx_mid_alt_sha = sha
+                ctx_mid_alt_len = str(tok_len)
+                ctx_anchor_has = True
+
+        if def_anchor_has:
+            def_anchor_available += 1
+        if ctx_anchor_has:
+            ctx_anchor_available += 1
+
+        def_head_spec = _spec(def_head_len, def_head_hash64, def_head_sha)
+        def_head_alt_spec = _spec(
+            def_head_alt_len,
+            def_head_alt_hash64,
+            def_head_alt_sha,
+        )
+        def_mid_spec = _spec(def_mid_len, def_mid_hash64, def_mid_sha)
+        def_mid_alt_spec = _spec(
+            def_mid_alt_len,
+            def_mid_alt_hash64,
+            def_mid_alt_sha,
+        )
+        def_tail_spec = _spec(def_tail_len, def_tail_hash64, def_tail_sha)
+        def_tail_alt_spec = _spec(
+            def_tail_alt_len,
+            def_tail_alt_hash64,
+            def_tail_alt_sha,
+        )
+        ctx_head_spec = _spec(ctx_head_len, ctx_head_hash64, ctx_head_sha)
+        ctx_head_alt_spec = _spec(
+            ctx_head_alt_len,
+            ctx_head_alt_hash64,
+            ctx_head_alt_sha,
+        )
+        ctx_mid_spec = _spec(ctx_mid_len, ctx_mid_hash64, ctx_mid_sha)
+        ctx_mid_alt_spec = _spec(
+            ctx_mid_alt_len,
+            ctx_mid_alt_hash64,
+            ctx_mid_alt_sha,
+        )
+        ctx_tail_spec = _spec(ctx_tail_len, ctx_tail_hash64, ctx_tail_sha)
+        ctx_tail_alt_spec = _spec(
+            ctx_tail_alt_len,
+            ctx_tail_alt_hash64,
+            ctx_tail_alt_sha,
+        )
+
+        token_index = token_cache.get(paper_id)
+        if doc_index is None:
+            missing_tei += 1
+        else:
+            def_span = doc_index.find_span(definition)
+            if def_span is not None:
+                def_start, def_end, def_match = def_span
+            else:
+                if def_hash64 and def_sha and def_tok_len and token_index:
+                    span = token_index.find_span_by_hash(
+                        int(def_tok_len),
+                        int(def_hash64),
+                        def_sha,
+                    )
+                    if span:
+                        def_start, def_end = span
+                        def_match = "hash"
+                    else:
+                        expected_len = int(def_tok_len or 0)
+                        head_specs = [
+                            spec
+                            for spec in (def_head_spec, def_head_alt_spec)
+                            if spec
+                        ]
+                        mid_specs = [
+                            spec
+                            for spec in (def_mid_spec, def_mid_alt_spec)
+                            if spec
+                        ]
+                        tail_specs = [
+                            spec
+                            for spec in (def_tail_spec, def_tail_alt_spec)
+                            if spec
+                        ]
+                        if token_index and expected_len and head_specs and tail_specs:
+                            for head in head_specs:
+                                for tail in tail_specs:
+                                    anchor_span = _find_span_by_anchors(
+                                        token_index,
+                                        head,
+                                        tail,
+                                        expected_len,
+                                        mid_specs=mid_specs,
+                                    )
+                                    if anchor_span:
+                                        def_start, def_end = anchor_span
+                                        def_match = "anchor"
+                                        break
+                                if def_match == "anchor":
+                                    break
+                        if (
+                            def_match != "anchor"
+                            and token_index
+                            and expected_len
+                        ):
+                            for spec, position in (
+                                (def_head_spec, "head"),
+                                (def_head_alt_spec, "head"),
+                                (def_mid_spec, "head"),
+                                (def_mid_alt_spec, "head"),
+                                (def_tail_spec, "tail"),
+                                (def_tail_alt_spec, "tail"),
+                            ):
+                                anchor_span = _find_span_from_anchor(
+                                    token_index,
+                                    spec,
+                                    expected_len,
+                                    position,
+                                    mid_specs=mid_specs,
+                                )
+                                if anchor_span:
+                                    def_start, def_end = anchor_span
+                                    def_match = "anchor"
+                                    break
+                        if def_match != "anchor":
+                            missing_def += 1
+                            missing_def_rows.append(
+                                {
+                                    "paper_id": paper_id,
+                                    "concept": row.get("concept", ""),
+                                    "reason": "missing_definition_span",
+                                },
+                            )
+                else:
+                    missing_def += 1
+                    missing_def_rows.append(
+                        {
+                            "paper_id": paper_id,
+                            "concept": row.get("concept", ""),
+                            "reason": "missing_definition_span",
+                        },
+                    )
+
+            ctx_span = doc_index.find_span(context)
+            if ctx_span is not None:
+                ctx_start, ctx_end, ctx_match = ctx_span
+            else:
+                if ctx_hash64 and ctx_sha and ctx_tok_len and token_index:
+                    span = token_index.find_span_by_hash(
+                        int(ctx_tok_len),
+                        int(ctx_hash64),
+                        ctx_sha,
+                    )
+                    if span:
+                        ctx_start, ctx_end = span
+                        ctx_match = "hash"
+                    else:
+                        expected_len = int(ctx_tok_len or 0)
+                        head_specs = [
+                            spec
+                            for spec in (ctx_head_spec, ctx_head_alt_spec)
+                            if spec
+                        ]
+                        mid_specs = [
+                            spec
+                            for spec in (ctx_mid_spec, ctx_mid_alt_spec)
+                            if spec
+                        ]
+                        tail_specs = [
+                            spec
+                            for spec in (ctx_tail_spec, ctx_tail_alt_spec)
+                            if spec
+                        ]
+                        if token_index and expected_len and head_specs and tail_specs:
+                            for head in head_specs:
+                                for tail in tail_specs:
+                                    anchor_span = _find_span_by_anchors(
+                                        token_index,
+                                        head,
+                                        tail,
+                                        expected_len,
+                                        mid_specs=mid_specs,
+                                    )
+                                    if anchor_span:
+                                        ctx_start, ctx_end = anchor_span
+                                        ctx_match = "anchor"
+                                        break
+                                if ctx_match == "anchor":
+                                    break
+                        if (
+                            ctx_match != "anchor"
+                            and token_index
+                            and expected_len
+                        ):
+                            for spec, position in (
+                                (ctx_head_spec, "head"),
+                                (ctx_head_alt_spec, "head"),
+                                (ctx_mid_spec, "head"),
+                                (ctx_mid_alt_spec, "head"),
+                                (ctx_tail_spec, "tail"),
+                                (ctx_tail_alt_spec, "tail"),
+                            ):
+                                anchor_span = _find_span_from_anchor(
+                                    token_index,
+                                    spec,
+                                    expected_len,
+                                    position,
+                                    mid_specs=mid_specs,
+                                )
+                                if anchor_span:
+                                    ctx_start, ctx_end = anchor_span
+                                    ctx_match = "anchor"
+                                    break
+                        if ctx_match != "anchor":
+                            missing_ctx += 1
+                            missing_ctx_rows.append(
+                                {
+                                    "paper_id": paper_id,
+                                    "concept": row.get("concept", ""),
+                                    "reason": "missing_context_span",
+                                },
+                            )
+                else:
+                    missing_ctx += 1
+                    missing_ctx_rows.append(
+                        {
+                            "paper_id": paper_id,
+                            "concept": row.get("concept", ""),
+                            "reason": "missing_context_span",
+                        },
+                    )
+
+        output_rows.append(
+            {
+                "paper_id": paper_id,
+                "paper_title": row.get("paper_title", ""),
+                "paper_doi": doi,
+                "paper_arxiv": arxiv,
+                "concept": row.get("concept", ""),
+                "definition_type": row.get("definition_type", ""),
+                "source_file": row.get("source_file", ""),
+                "is_out_of_domain": row.get("is_out_of_domain", ""),
+                "definition_preserve_linebreaks": def_preserve_linebreaks,
+                "context_preserve_linebreaks": ctx_preserve_linebreaks,
+                "definition_preserve_hyphenation": def_preserve_hyphenation,
+                "context_preserve_hyphenation": ctx_preserve_hyphenation,
+                "definition_has_bracket_citation": def_has_bracket_citation,
+                "definition_has_paren_citation": def_has_paren_citation,
+                "definition_has_letter_digit": def_has_letter_digit,
+                "context_has_bracket_citation": ctx_has_bracket_citation,
+                "context_has_paren_citation": ctx_has_paren_citation,
+                "context_has_letter_digit": ctx_has_letter_digit,
+                "definition_end_punct": def_end_punct,
+                "context_end_punct": ctx_end_punct,
+                "marker_version": "grobid_text_v1",
+                "hash_version": HASH_VERSION,
+                "definition_char_start": def_start,
+                "definition_char_end": def_end,
+                "definition_match": def_match,
+                "definition_hash64": def_hash64,
+                "definition_sha256": def_sha,
+                "definition_token_count": def_tok_len,
+                "definition_head_hash64": def_head_hash64,
+                "definition_head_sha256": def_head_sha,
+                "definition_head_token_count": def_head_len,
+                "definition_mid_hash64": def_mid_hash64,
+                "definition_mid_sha256": def_mid_sha,
+                "definition_mid_token_count": def_mid_len,
+                "definition_tail_hash64": def_tail_hash64,
+                "definition_tail_sha256": def_tail_sha,
+                "definition_tail_token_count": def_tail_len,
+                "definition_head_alt_hash64": def_head_alt_hash64,
+                "definition_head_alt_sha256": def_head_alt_sha,
+                "definition_head_alt_token_count": def_head_alt_len,
+                "definition_mid_alt_hash64": def_mid_alt_hash64,
+                "definition_mid_alt_sha256": def_mid_alt_sha,
+                "definition_mid_alt_token_count": def_mid_alt_len,
+                "definition_tail_alt_hash64": def_tail_alt_hash64,
+                "definition_tail_alt_sha256": def_tail_alt_sha,
+                "definition_tail_alt_token_count": def_tail_alt_len,
+                "context_char_start": ctx_start,
+                "context_char_end": ctx_end,
+                "context_match": ctx_match,
+                "context_hash64": ctx_hash64,
+                "context_sha256": ctx_sha,
+                "context_token_count": ctx_tok_len,
+                "context_head_hash64": ctx_head_hash64,
+                "context_head_sha256": ctx_head_sha,
+                "context_head_token_count": ctx_head_len,
+                "context_mid_hash64": ctx_mid_hash64,
+                "context_mid_sha256": ctx_mid_sha,
+                "context_mid_token_count": ctx_mid_len,
+                "context_tail_hash64": ctx_tail_hash64,
+                "context_tail_sha256": ctx_tail_sha,
+                "context_tail_token_count": ctx_tail_len,
+                "context_head_alt_hash64": ctx_head_alt_hash64,
+                "context_head_alt_sha256": ctx_head_alt_sha,
+                "context_head_alt_token_count": ctx_head_alt_len,
+                "context_mid_alt_hash64": ctx_mid_alt_hash64,
+                "context_mid_alt_sha256": ctx_mid_alt_sha,
+                "context_mid_alt_token_count": ctx_mid_alt_len,
+                "context_tail_alt_hash64": ctx_tail_alt_hash64,
+                "context_tail_alt_sha256": ctx_tail_alt_sha,
+                "context_tail_alt_token_count": ctx_tail_alt_len,
+            },
+        )
+
+    fieldnames = [
+        "paper_id",
+        "paper_title",
+        "paper_doi",
+        "paper_arxiv",
+        "concept",
+        "definition_type",
+        "source_file",
+        "is_out_of_domain",
+        "definition_preserve_linebreaks",
+        "context_preserve_linebreaks",
+        "definition_preserve_hyphenation",
+        "context_preserve_hyphenation",
+        "definition_has_bracket_citation",
+        "definition_has_paren_citation",
+        "definition_has_letter_digit",
+        "context_has_bracket_citation",
+        "context_has_paren_citation",
+        "context_has_letter_digit",
+        "definition_end_punct",
+        "context_end_punct",
+        "marker_version",
+        "hash_version",
+        "definition_char_start",
+        "definition_char_end",
+        "definition_match",
+        "definition_hash64",
+        "definition_sha256",
+        "definition_token_count",
+        "definition_head_hash64",
+        "definition_head_sha256",
+        "definition_head_token_count",
+        "definition_mid_hash64",
+        "definition_mid_sha256",
+        "definition_mid_token_count",
+        "definition_tail_hash64",
+        "definition_tail_sha256",
+        "definition_tail_token_count",
+        "definition_head_alt_hash64",
+        "definition_head_alt_sha256",
+        "definition_head_alt_token_count",
+        "definition_mid_alt_hash64",
+        "definition_mid_alt_sha256",
+        "definition_mid_alt_token_count",
+        "definition_tail_alt_hash64",
+        "definition_tail_alt_sha256",
+        "definition_tail_alt_token_count",
+        "context_char_start",
+        "context_char_end",
+        "context_match",
+        "context_hash64",
+        "context_sha256",
+        "context_token_count",
+        "context_head_hash64",
+        "context_head_sha256",
+        "context_head_token_count",
+        "context_mid_hash64",
+        "context_mid_sha256",
+        "context_mid_token_count",
+        "context_tail_hash64",
+        "context_tail_sha256",
+        "context_tail_token_count",
+        "context_head_alt_hash64",
+        "context_head_alt_sha256",
+        "context_head_alt_token_count",
+        "context_mid_alt_hash64",
+        "context_mid_alt_sha256",
+        "context_mid_alt_token_count",
+        "context_tail_alt_hash64",
+        "context_tail_alt_sha256",
+        "context_tail_alt_token_count",
+    ]
+
+    args.output_csv.parent.mkdir(parents=True, exist_ok=True)
+    with args.output_csv.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in output_rows:
+            writer.writerow(row)
+
+    total = len(output_rows)
+    print(f"Wrote {total} rows to {args.output_csv}")
+    print(
+        "Exact TEI spans missing - "
+        f"TEI: {missing_tei}, def spans: {missing_def}, ctx spans: {missing_ctx}",
+    )
+    print(
+        "Hash/anchor markers available - "
+        f"def hash: {def_hash_available}/{total}, "
+        f"ctx hash: {ctx_hash_available}/{total}, "
+        f"def anchors: {def_anchor_available}/{total}, "
+        f"ctx anchors: {ctx_anchor_available}/{total}",
+    )
+    print(
+        "Note: missing exact TEI spans do not block hydration; "
+        "hash/anchor markers are used as the primary fallback.",
+    )
+
+    if args.report is not None:
+        report_lines = []
+        if missing_tei:
+            report_lines.append(f"Missing TEI: {missing_tei}")
+        report_lines.append(f"Missing definition spans: {missing_def}")
+        report_lines.append(f"Missing context spans: {missing_ctx}")
+        if missing_def_rows:
+            report_lines.append("")
+            report_lines.append("Missing definitions (paper_id | concept):")
+            for item in missing_def_rows:
+                report_lines.append(
+                    f"- {item['paper_id']} | {item['concept']}",
+                )
+        if missing_ctx_rows:
+            report_lines.append("")
+            report_lines.append("Missing contexts (paper_id | concept):")
+            for item in missing_ctx_rows:
+                report_lines.append(
+                    f"- {item['paper_id']} | {item['concept']}",
+                )
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text(
+            "\n".join(report_lines) + "\n",
+            encoding="utf-8",
+        )
+        print(f"Wrote report to {args.report}")
+
+
+if __name__ == "__main__":
+    main()

scripts/report_defextra_status.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+# ruff: noqa: E402
+
+import argparse
+import csv
+import re
+import time
+from pathlib import Path
+from typing import Dict, Tuple
+
+try:
+    from scripts.defextra_markers import normalize_paper_id
+except ModuleNotFoundError as exc:
+    if exc.name != "scripts":
+        raise
+    import sys
+
+    PROJECT_ROOT = Path(__file__).resolve().parent.parent
+    if str(PROJECT_ROOT) not in sys.path:
+        sys.path.insert(0, str(PROJECT_ROOT))
+    from scripts.defextra_markers import normalize_paper_id
+
+
+def _normalize_title(title: str) -> str:
+    return " ".join((title or "").lower().split())
+
+
+def _load_csv(path: Path) -> list[dict]:
+    with path.open(encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle))
+
+
+def _parse_missing_report(path: Path) -> Tuple[list[str], list[str]]:
+    missing_defs: list[str] = []
+    missing_ctxs: list[str] = []
+    if not path.exists():
+        return missing_defs, missing_ctxs
+    section = None
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if line.startswith("Missing definitions"):
+            section = "def"
+            continue
+        if line.startswith("Missing contexts"):
+            section = "ctx"
+            continue
+        if not line.startswith("-"):
+            continue
+        item = line[1:].strip()
+        if section == "def":
+            missing_defs.append(item)
+        elif section == "ctx":
+            missing_ctxs.append(item)
+    return missing_defs, missing_ctxs
+
+
+def _index_recent_pdfs(
+    pdf_dir: Path,
+    cutoff_ts: float,
+) -> Dict[str, Path]:
+    index: Dict[str, Path] = {}
+    if not pdf_dir.exists():
+        return index
+    version_re = re.compile(r"^(?P<base>.+?)(v\d+)$", re.IGNORECASE)
+    arxiv_re = re.compile(r"^(?P<base>\d{4}\.\d{4,5})v\d+$", re.IGNORECASE)
+    pii_re = re.compile(r"(S\d{8,})", re.IGNORECASE)
+    for suffix in ("*.pdf", "*.PDF"):
+        for path in pdf_dir.rglob(suffix):
+            try:
+                if path.stat().st_mtime < cutoff_ts:
+                    continue
+            except OSError:
+                continue
+            stem = path.stem
+            keys = {stem, stem.lower(), normalize_paper_id(stem)}
+            if stem.startswith("paper_"):
+                stripped = stem[len("paper_") :]
+                keys.update({stripped, stripped.lower(), normalize_paper_id(stripped)})
+            if stem.endswith("_fixed") or stem.endswith("-fixed"):
+                base = stem[: -len("_fixed")] if stem.endswith("_fixed") else stem[: -len("-fixed")]
+                if base:
+                    keys.update({base, base.lower(), normalize_paper_id(base)})
+            match = arxiv_re.match(stem)
+            if match:
+                base = match.group("base")
+                keys.update({base, base.lower(), normalize_paper_id(base)})
+            match = version_re.match(stem)
+            if match:
+                base = match.group("base")
+                keys.update({base, base.lower(), normalize_paper_id(base)})
+            pii_match = pii_re.search(stem)
+            if pii_match:
+                pii = pii_match.group(1)
+                keys.update({pii, pii.lower(), normalize_paper_id(pii)})
+            for key in keys:
+                if key:
+                    index.setdefault(key, path)
+    return index
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Report DefExtra hydration coverage and missing spans.",
+    )
+    parser.add_argument(
+        "--legal-csv",
+        type=Path,
+        default=Path("results/paper_results/defextra_legal_tablefix.csv"),
+        help="Legal CSV used for hydration.",
+    )
+    parser.add_argument(
+        "--legal-report",
+        type=Path,
+        default=Path("results/paper_results/defextra_legal_tablefix_report.txt"),
+        help="Report generated by prepare_defextra_legal.py.",
+    )
+    parser.add_argument(
+        "--hydrated-csv",
+        type=Path,
+        default=Path("results/paper_results/defextra_hydrated_tablefix_test.csv"),
+        help="Hydrated CSV from hydrate_defextra.py.",
+    )
+    parser.add_argument(
+        "--pdf-dir",
+        type=Path,
+        default=Path("ManualPDFsGROBID/manual_pdfs/manual_pdfs"),
+        help="Directory with user PDFs (used to tag recent downloads).",
+    )
+    parser.add_argument(
+        "--recent-days",
+        type=int,
+        default=7,
+        help="How many days count as 'recent' for PDF downloads.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=None,
+        help="Optional report output path.",
+    )
+    args = parser.parse_args()
+
+    legal_rows = _load_csv(args.legal_csv)
+    hydrated_rows = _load_csv(args.hydrated_csv) if args.hydrated_csv.exists() else []
+
+    ref_ids = {row.get("paper_id", "") for row in legal_rows if row.get("paper_id")}
+    hyd_ids = {row.get("paper_id", "") for row in hydrated_rows if row.get("paper_id")}
+    missing_papers = sorted(ref_ids - hyd_ids)
+
+    missing_defs, missing_ctxs = _parse_missing_report(args.legal_report)
+
+    idx = {
+        (row.get("paper_id", ""), row.get("concept", "")): row
+        for row in legal_rows
+    }
+
+    implicit_defs = []
+    implicit_ctxs = []
+    for item in missing_defs:
+        try:
+            pid, concept = [p.strip() for p in item.split("|", 1)]
+        except ValueError:
+            continue
+        row = idx.get((pid, concept))
+        if row and (row.get("definition_type") or "").strip().lower() == "implicit":
+            implicit_defs.append(item)
+    for item in missing_ctxs:
+        try:
+            pid, concept = [p.strip() for p in item.split("|", 1)]
+        except ValueError:
+            continue
+        row = idx.get((pid, concept))
+        if row and (row.get("definition_type") or "").strip().lower() == "implicit":
+            implicit_ctxs.append(item)
+
+    cutoff_ts = time.time() - (args.recent_days * 86400)
+    recent_index = _index_recent_pdfs(args.pdf_dir, cutoff_ts)
+
+    recent_missing_defs = []
+    recent_missing_ctxs = []
+    recent_missing_papers = []
+
+    for pid in missing_papers:
+        if pid in recent_index or normalize_paper_id(pid) in recent_index:
+            recent_missing_papers.append(pid)
+
+    for item in missing_defs:
+        try:
+            pid, concept = [p.strip() for p in item.split("|", 1)]
+        except ValueError:
+            continue
+        if pid in recent_index or normalize_paper_id(pid) in recent_index:
+            recent_missing_defs.append(item)
+
+    for item in missing_ctxs:
+        try:
+            pid, concept = [p.strip() for p in item.split("|", 1)]
+        except ValueError:
+            continue
+        if pid in recent_index or normalize_paper_id(pid) in recent_index:
+            recent_missing_ctxs.append(item)
+
+    lines = []
+    lines.append(f"Missing papers (no hydrated rows): {len(missing_papers)}")
+    for pid in missing_papers:
+        lines.append(f"- {pid}")
+    lines.append("")
+    lines.append(f"Missing definition spans marked implicit: {len(implicit_defs)}")
+    for item in implicit_defs:
+        lines.append(f"- {item}")
+    lines.append("")
+    lines.append(f"Missing context spans marked implicit: {len(implicit_ctxs)}")
+    for item in implicit_ctxs:
+        lines.append(f"- {item}")
+    lines.append("")
+    lines.append(
+        f"Missing papers with recent PDFs (<= {args.recent_days} days): "
+        f"{len(recent_missing_papers)}"
+    )
+    for pid in recent_missing_papers:
+        lines.append(f"- {pid}")
+    lines.append("")
+    lines.append(
+        f"Missing definition spans with recent PDFs (<= {args.recent_days} days): "
+        f"{len(recent_missing_defs)}"
+    )
+    for item in recent_missing_defs:
+        lines.append(f"- {item}")
+    lines.append("")
+    lines.append(
+        f"Missing context spans with recent PDFs (<= {args.recent_days} days): "
+        f"{len(recent_missing_ctxs)}"
+    )
+    for item in recent_missing_ctxs:
+        lines.append(f"- {item}")
+    lines.append("")
+
+    output = "\n".join(lines) + "\n"
+    if args.output is not None:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(output, encoding="utf-8")
+        print(f"Wrote report to {args.output}")
+    else:
+        print(output)
+
+
+if __name__ == "__main__":
+    main()