Fix LFS tracking + add phylogenetic relationship metadata

- Fix .gitattributes: add *.tsv and *.csv LFS rules (missing since
Mar 13 re-init). All TSV/CSV files now properly LFS-tracked.
- Add phylo_pairs.tsv: 386K language pair classifications from
Glottolog CLDF v5.x (99.4% coverage, 45K tests pass)
- Add 4 phylo enrichment scripts + PRD
- Update DATABASE_REFERENCE.md with phylo_pairs documentation

.gitattributes

@@ -58,8 +58,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
-data/training/cognate_pairs/cognate_pairs_inherited.tsv filter=lfs diff=lfs merge=lfs -text
-data/training/cognate_pairs/cognate_pairs_similarity.tsv filter=lfs diff=lfs merge=lfs -text
+# Dataset files
 *.tsv filter=lfs diff=lfs merge=lfs -text
 *.csv filter=lfs diff=lfs merge=lfs -text
 *.pdf filter=lfs diff=lfs merge=lfs -text

data/training/metadata/phylo_pairs.tsv

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

docs/DATABASE_REFERENCE.md

@@ -44,7 +44,7 @@ This document is the single source of truth for understanding, modifying, and ex
 - `scripts/` — All extraction and processing scripts
 - `cognate_pipeline/` — Python package for phonetic processing
 - `docs/` — PRDs, audit reports, this reference doc
-- `data/training/metadata/` — `languages.tsv`, `source_stats.tsv` (small summary files)
+- `data/training/metadata/` — `languages.tsv`, `source_stats.tsv`, `phylo_pairs.tsv` (small summary/lookup files)
 - `data/training/validation/` — Validation sets (via Git LFS)
 - `data/training/lexicons/*.tsv` — Ancient language TSVs (force-added despite gitignore)
 
@@ -108,7 +108,7 @@ python scripts/assemble_lexicons.py        # Generate metadata
 ancient-scripts-datasets/
   data/training/
     lexicons/           # 1,136 TSV files (one per language) [GITIGNORED]
-    metadata/           # languages.tsv, source_stats.tsv, etc. [TRACKED]
+    metadata/           # languages.tsv, source_stats.tsv, phylo_pairs.tsv [TRACKED]
     cognate_pairs/      # inherited, similarity, borrowing pairs [GITIGNORED]
     validation/         # stratified ML training/test sets [GIT LFS]
     language_profiles/  # per-language markdown profiles
@@ -153,6 +153,42 @@ Lang_A  Word_A  IPA_A  Lang_B  Word_B  IPA_B  Concept_ID  Relationship  Score  S
 
 **Adversarial audit status (2026-03-14):** All 3 output files PASS final audit. Zero cross-file contamination, zero self-pairs, zero isolate/constructed language leakage, all Source_Record_IDs traceable to source databases.
 
+### Phylogenetic Relationship Metadata
+
+**File:** `data/training/metadata/phylo_pairs.tsv` (386,101 unique language pairs)
+
+A lookup table mapping every unique `(Lang_A, Lang_B)` pair in the cognate dataset to its phylogenetic relationship, based on Glottolog CLDF v5.x (Hammarström et al.). Not stored inline in the 23M-row cognate files to avoid redundancy.
+
+**Schema (9 columns, tab-separated):**
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `Lang_A` | str | ISO 639-3 code (alphabetically first) |
+| `Lang_B` | str | ISO 639-3 code (alphabetically second) |
+| `Phylo_Relation` | enum | `near_ancestral`, `close_sister`, `distant_sister`, `cross_family`, `unclassified` |
+| `Tree_Distance` | int | Edge count through MRCA (99 = unclassified/cross-family) |
+| `MRCA_Clade` | str | Glottocode of MRCA node |
+| `MRCA_Depth` | int | Depth of MRCA in tree (0 = root) |
+| `Ancestor_Lang` | str | For `near_ancestral`: ISO of the ancestor; `-` otherwise |
+| `Family_A` | str | Top-level Glottolog family of Lang_A |
+| `Family_B` | str | Top-level Glottolog family of Lang_B |
+
+**Distribution:**
+
+| Relation | Count | Percentage |
+|----------|-------|------------|
+| `distant_sister` | 249,392 | 64.6% |
+| `close_sister` | 87,078 | 22.6% |
+| `cross_family` | 45,267 | 11.7% |
+| `unclassified` | 4,302 | 1.1% |
+| `near_ancestral` | 62 | 0.0% |
+
+**Usage:** Join at query time using `pair_key = (min(a,b), max(a,b))`. The classification is orthogonal to the cognate data and can be updated independently when Glottolog releases new versions.
+
+**Scripts:** `scripts/ingest_glottolog.py` (download), `scripts/build_glottolog_tree.py` (parse), `scripts/build_phylo_pairs.py` (classify), `scripts/validate_phylo_pairs.py` (validate). See `docs/prd/PRD_PHYLO_ENRICHMENT.md` for full specification.
+
+**Validation (2026-03-14):** 45,363/45,363 tests passed. 13 known-answer checks, 62 near-ancestral integrity, 45,267 cross-family integrity, 99.4% ISO coverage, 20/20 random audit.
+
 ---
 
 ## 2. TSV Schema & Format

docs/prd/PRD_PHYLO_ENRICHMENT.md

@@ -0,0 +1,179 @@
+# PRD: Phylogenetic Relationship Metadata for Cognate Pairs
+
+**Status**: In Progress
+**Date**: 2026-03-14
+**Author**: Alvin (assisted by Claude)
+
+---
+
+## Problem
+
+The cognate pair dataset (23.4M pairs) currently has NO metadata about the phylogenetic relationship between language pairs — no distinction between mother-daughter (Latin→Spanish), close sisters (Spanish~Italian), or distant sisters (Spanish~Hindi). Every pair should indicate its degree of cognacy.
+
+## Solution
+
+A post-processing enrichment pipeline that cross-references cognate pairs against an authoritative phylogenetic tree (Glottolog CLDF v5.x) to classify each unique language pair.
+
+---
+
+## Data Source
+
+**Primary**: Glottolog CLDF v5.x (Hammarström, Forkel, Haspelmath & Bank)
+- Repository: `https://github.com/glottolog/glottolog-cldf`
+- Archive: Zenodo DOI: 10.5281/zenodo.15640174
+- License: CC BY 4.0
+- Key files: `cldf/languages.csv` (27,177 languoids with ISO mapping), `cldf/classification.nex` (NEXUS with Newick trees per family)
+- 8,184 languoids have ISO 639-3 codes
+- Trees are topological (no branch lengths)
+
+**Download method**: `scripts/ingest_glottolog.py` — downloads the CLDF CSV and NEXUS files from GitHub raw content into `data/training/raw/glottolog_cldf/`. Follows the same pattern as `ingest_acd.py`.
+
+**Supplementary** (Phase 2, not in scope): Phlorest Bayesian phylogenies for calibrated branch lengths (years of divergence).
+
+---
+
+## Output
+
+**File**: `data/training/metadata/phylo_pairs.tsv`
+
+A lookup table keyed on canonically-ordered `(Lang_A, Lang_B)` pairs. NOT inline columns in the 23M-row cognate pair files — that would add massive redundancy since the same language pair always has the same phylo classification.
+
+### Schema (9 columns)
+
+| Column | Type | Description |
+|--------|------|-------------|
+| `Lang_A` | str | ISO 639-3 code (alphabetically first) |
+| `Lang_B` | str | ISO 639-3 code (alphabetically second) |
+| `Phylo_Relation` | enum | `near_ancestral`, `close_sister`, `distant_sister`, `cross_family`, `unclassified` |
+| `Tree_Distance` | int | Edge count through MRCA (0 = same leaf group, 99 = unclassified/cross-family) |
+| `MRCA_Clade` | str | Glottocode or name of MRCA node (e.g., `roma1334`, `germ1287`) |
+| `MRCA_Depth` | int | Depth of MRCA in tree (0 = root, higher = more specific) |
+| `Ancestor_Lang` | str | For `near_ancestral`: ISO of the ancestor. `-` otherwise |
+| `Family_A` | str | Top-level Glottolog family of Lang_A |
+| `Family_B` | str | Top-level Glottolog family of Lang_B |
+
+### Classification Taxonomy
+
+| Relation | Definition | Example |
+|----------|-----------|---------|
+| `near_ancestral` | One language is an attested ancestor of the other's clade (from curated NEAR_ANCESTOR_MAP) | Latin↔Spanish, Old English↔English, Sanskrit↔Hindi |
+| `close_sister` | MRCA depth ≥ 3 (share a specific sub-branch) | Spanish↔Italian (both under Romance), Swedish↔Danish (both under North Germanic) |
+| `distant_sister` | MRCA depth = 1 or 2 (share family or major branch only) | English↔Hindi (both IE, but Germanic vs Indo-Iranian) |
+| `cross_family` | Different top-level families | English↔Japanese |
+| `unclassified` | One or both languages not in Glottolog tree | Undeciphered/isolate languages without Glottocode |
+
+**Depth thresholds**: The boundary between close and distant is at MRCA depth 3+. This means:
+- Depth 0: root (should not occur for same-family pairs)
+- Depth 1: top-level family (e.g., `indo1319` = Indo-European) → `distant_sister`
+- Depth 2: major branch (e.g., `germ1287` = Germanic) → `distant_sister`
+- Depth 3+: sub-branch (e.g., `west2793` = West Germanic) → `close_sister`
+
+### Near-Ancestral Detection
+
+A curated `NEAR_ANCESTOR_MAP` lists ~25 attested ancient/medieval languages and the Glottolog clades they are historically ancestral to:
+
+```python
+NEAR_ANCESTOR_MAP = {
+    "lat": ["roma1334"],           # Latin → Romance
+    "grc": ["mode1248", "medi1251"],  # Ancient Greek → Modern Greek clades
+    "san": ["indo1321"],           # Sanskrit → Indic
+    "ang": ["angl1265"],           # Old English → Anglian/English
+    "enm": ["angl1265"],           # Middle English → English
+    "fro": ["oilf1242"],           # Old French → Oïl French
+    "osp": ["cast1243"],           # Old Spanish → Castilian
+    "non": ["nort3160"],           # Old Norse → North Germanic modern
+    "goh": ["high1289"],           # Old High German → High German
+    "dum": ["mode1258"],           # Middle Dutch → Modern Dutch
+    "sga": ["goid1240"],           # Old Irish → Goidelic modern
+    "mga": ["goid1240"],           # Middle Irish → Goidelic modern
+    "wlm": ["bryt1239"],           # Middle Welsh → Brythonic modern
+    "chu": ["sout3147"],           # Old Church Slavonic → South Slavic
+    "orv": ["east1426"],           # Old East Slavic → East Slavic modern
+    "och": ["sini1245"],           # Old Chinese → Sinitic modern
+    "ota": ["oghu1243"],           # Ottoman Turkish → Oghuz modern
+    "okm": ["kore1284"],           # Middle Korean → Korean modern
+}
+```
+
+Logic:
+1. If either language is in `NEAR_ANCESTOR_MAP`
+2. AND the other language's ancestry path in Glottolog passes through one of the listed descendant clades
+3. AND the other language is NOT itself an ancient/medieval language (to avoid classifying Latin↔Oscan as near_ancestral)
+4. THEN classify as `near_ancestral` with `Ancestor_Lang` = the ancient language's ISO
+
+**Gothic (`got`) edge case**: Gothic is ancient but has NO modern descendants (East Germanic is extinct). Gothic↔Swedish should be `distant_sister`, not `near_ancestral`. The map correctly handles this by only listing clades with living descendants.
+
+---
+
+## Scripts
+
+### Script 1: `scripts/ingest_glottolog.py`
+Downloads Glottolog CLDF data from GitHub.
+
+### Script 2: `scripts/build_glottolog_tree.py`
+Parses the Glottolog NEXUS file into a usable Python tree structure.
+
+### Script 3: `scripts/build_phylo_pairs.py`
+The main enrichment script that generates the lookup table.
+
+### Script 4: `scripts/validate_phylo_pairs.py`
+Validation script with known-answer checks.
+
+---
+
+## Execution Order
+
+1. Write PRD → push to `docs/prd/PRD_PHYLO_ENRICHMENT.md`
+2. Write `scripts/ingest_glottolog.py` → download Glottolog CLDF
+3. Write `scripts/build_glottolog_tree.py` → parse NEXUS, build tree index
+4. Adversarial audit: Verify tree covers ≥95% of ISO codes in cognate pairs
+5. Write `scripts/build_phylo_pairs.py` → generate lookup table
+6. Adversarial audit: Verify 20 random pairs trace back to Glottolog tree
+7. Write `scripts/validate_phylo_pairs.py` → automated known-answer tests
+8. Update `docs/DATABASE_REFERENCE.md` with phylo_pairs documentation
+9. Commit + push to GitHub + HuggingFace
+
+---
+
+## Critical Design Decisions
+
+### Why a separate lookup table (not inline columns)?
+- The 22.9M inherited pairs reference ~385K unique language pairs. Adding 7 columns to 22.9M rows = 160M+ redundant cells.
+- Downstream consumers join at query time: `pair_key = (min(a,b), max(a,b))`; lookup is O(1) with a dict.
+- The phylo classification is orthogonal to the cognate data — it can be updated independently when Glottolog releases new versions.
+
+### Why Glottolog (not the existing phylo_tree.json)?
+- `phylo_tree.json` has 755 Austronesian languages in ONE flat list — zero sub-classification for 90% of the dataset
+- Glottolog has deep sub-classification for ALL families including Austronesian
+- Glottolog is the authoritative academic reference (Hammarström et al.)
+
+### Why curated near-ancestor map (not purely algorithmic)?
+- Glottolog classifies ALL attested languages as leaf nodes (siblings), never as parent nodes
+- Even Latin is a sibling of Romance under "Imperial Latin" in Glottolog — not a parent
+- Algorithmic detection from tree topology alone would classify ALL pairs as sister-sister
+- The curated map (~25 entries) is linguistically defensible and small enough to verify exhaustively
+
+### Why not branch-length / time-calibrated distances?
+- Phase 1 focuses on topological classification
+- Branch-length data requires Phlorest Bayesian phylogenies (separate download per family, inconsistent coverage)
+- Branch lengths can be added in Phase 2 as a `Divergence_Years` column
+
+---
+
+## Honest Limitations
+
+1. **"Near-ancestral" is approximate**: Latin is not literally the ancestor of French — Vulgar Latin (unattested) is. We use "near-ancestral" to mean "the attested language is historically ancestral to the clade containing the other language."
+2. **Topological distance ≠ temporal distance**: Two languages with tree_distance=4 in Austronesian may have diverged 1,000 years ago, while two with tree_distance=4 in Indo-European may have diverged 5,000 years ago.
+3. **Glottolog is a single hypothesis**: Disputed affiliations are not represented. The tree reflects Glottolog's conservative consensus classification.
+4. **The similarity file (465K pairs) may contain cross-family pairs** that are correctly labeled `cross_family` — these are algorithmic similarity matches, not genetic relationships.
+5. **Proto-language codes (ine-pro, gem-pro, etc.) are NOT in Glottolog** — any cognate pairs involving proto-languages will be `unclassified`. (Currently zero such pairs exist in the dataset.)
+
+---
+
+## Verification
+
+1. `python scripts/validate_phylo_pairs.py` — all known-answer checks PASS
+2. Coverage: ≥95% of ISO codes in cognate pairs have a Glottolog classification
+3. Distribution: `close_sister` should be majority (most pairs are intra-family from ABVD/ACD)
+4. Adversarial audit: 20 random pairs traced back to Glottolog NEXUS tree
+5. No `unclassified` for any language that has a Glottocode in `languages.tsv`

scripts/build_glottolog_tree.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""Parse Glottolog NEXUS classification into a JSON tree index.
+
+Reads the Glottolog CLDF languages.csv and classification.nex files,
+builds ancestry paths for every ISO-bearing languoid, and writes
+a JSON index mapping ISO codes to their tree positions.
+
+Usage:
+    python scripts/build_glottolog_tree.py
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import logging
+import re
+import sys
+from pathlib import Path
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
+
+ROOT = Path(__file__).resolve().parent.parent
+logger = logging.getLogger(__name__)
+
+GLOTTOLOG_DIR = ROOT / "data" / "training" / "raw" / "glottolog_cldf"
+OUTPUT_FILE = GLOTTOLOG_DIR / "glottolog_tree.json"
+
+
+def parse_newick(newick: str) -> dict:
+    """Parse a Newick tree string into a parent->children dict.
+
+    Returns a dict mapping each node label to its list of child labels,
+    plus a special key '_root' with the root label.
+
+    The Glottolog NEXUS uses format: (child1:1,child2:1)parent:1
+    """
+    # Remove trailing semicolon
+    newick = newick.strip().rstrip(";")
+
+    children_of: dict[str, list[str]] = {}
+    parent_of: dict[str, str] = {}
+
+    # Parse by walking the string character by character
+    stack: list[list[str]] = []  # stack of child-lists being built
+    i = 0
+    n = len(newick)
+
+    while i < n:
+        c = newick[i]
+        if c == "(":
+            stack.append([])
+            i += 1
+        elif c == ")":
+            # Read the label after the closing paren
+            i += 1
+            label, i = _read_label(newick, i)
+            child_list = stack.pop()
+            children_of[label] = child_list
+            for child in child_list:
+                parent_of[child] = label
+            # Add this node to parent's child list (if any)
+            if stack:
+                stack[-1].append(label)
+            else:
+                # This is the root
+                children_of["_root"] = label
+        elif c == ",":
+            i += 1
+        else:
+            # Leaf node
+            label, i = _read_label(newick, i)
+            if stack:
+                stack[-1].append(label)
+            else:
+                children_of["_root"] = label
+
+    return children_of
+
+
+def _read_label(s: str, i: int) -> tuple[str, int]:
+    """Read a node label (glottocode) and skip any :branchlength suffix."""
+    start = i
+    while i < len(s) and s[i] not in "(),;":
+        i += 1
+    raw = s[start:i]
+    # Strip branch length (e.g., "abkh1242:1" -> "abkh1242")
+    label = raw.split(":")[0]
+    return label, i
+
+
+def build_ancestry_paths(children_of: dict) -> dict[str, list[str]]:
+    """Build leaf-to-root ancestry paths from a parsed tree.
+
+    Returns dict mapping each leaf label to its full path [root, ..., leaf].
+    """
+    root = children_of["_root"]
+
+    # Build parent lookup
+    parent_of: dict[str, str] = {}
+    for node, kids in children_of.items():
+        if node == "_root":
+            continue
+        if isinstance(kids, list):
+            for kid in kids:
+                parent_of[kid] = node
+
+    # Find all leaves (nodes not in children_of, or with no children)
+    all_nodes = set()
+    all_nodes.add(root)
+    for node, kids in children_of.items():
+        if node == "_root":
+            continue
+        all_nodes.add(node)
+        if isinstance(kids, list):
+            for kid in kids:
+                all_nodes.add(kid)
+
+    internal = {n for n in children_of if n != "_root" and isinstance(children_of.get(n), list)}
+    leaves = all_nodes - internal
+
+    # Build paths
+    paths: dict[str, list[str]] = {}
+    for leaf in leaves:
+        path = [leaf]
+        node = leaf
+        while node in parent_of:
+            node = parent_of[node]
+            path.append(node)
+        path.reverse()  # root -> ... -> leaf
+        paths[leaf] = path
+
+    # Also store paths for internal nodes (needed for languoids that are families)
+    for node in internal:
+        path = [node]
+        n = node
+        while n in parent_of:
+            n = parent_of[n]
+            path.append(n)
+        path.reverse()
+        paths[node] = path
+
+    return paths
+
+
+def load_iso_mapping() -> dict[str, tuple[str, str]]:
+    """Load ISO 639-3 -> (glottocode, family_id) mapping from languages.csv.
+
+    Returns dict mapping ISO code to (glottocode, family_id).
+    """
+    lang_file = GLOTTOLOG_DIR / "languages.csv"
+    mapping: dict[str, tuple[str, str]] = {}
+    with open(lang_file, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            iso = row.get("ISO639P3code", "").strip()
+            if iso:
+                gc = row["Glottocode"]
+                fam = row.get("Family_ID", "").strip()
+                mapping[iso] = (gc, fam)
+    return mapping
+
+
+def load_family_names() -> dict[str, str]:
+    """Load glottocode -> name mapping for family-level nodes."""
+    lang_file = GLOTTOLOG_DIR / "languages.csv"
+    names: dict[str, str] = {}
+    with open(lang_file, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            gc = row["Glottocode"]
+            names[gc] = row["Name"]
+    return names
+
+
+def parse_nexus_file() -> dict[str, dict]:
+    """Parse the full NEXUS file, return {family_glottocode: children_of_dict}."""
+    nex_file = GLOTTOLOG_DIR / "classification.nex"
+    trees: dict[str, dict] = {}
+
+    with open(nex_file, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line.startswith("tree "):
+                continue
+            # Parse: tree <name> = [&R] <newick>;
+            m = re.match(r"tree\s+(\S+)\s*=\s*(?:\[&R\]\s*)?(.+)", line)
+            if not m:
+                continue
+            tree_name = m.group(1)
+            newick = m.group(2)
+            try:
+                children_of = parse_newick(newick)
+                trees[tree_name] = children_of
+            except Exception as e:
+                logger.warning("Failed to parse tree %s: %s", tree_name, e)
+
+    return trees
+
+
+def build_tree_index() -> dict:
+    """Build the complete tree index: ISO -> tree position info.
+
+    Returns a dict with:
+      - "languages": {iso: {glottocode, path, family, depth}}
+      - "family_names": {glottocode: name}
+    """
+    logger.info("Loading ISO mapping...")
+    iso_map = load_iso_mapping()
+    logger.info("Loaded %d ISO codes", len(iso_map))
+
+    logger.info("Loading family names...")
+    gc_names = load_family_names()
+
+    logger.info("Parsing NEXUS trees...")
+    trees = parse_nexus_file()
+    logger.info("Parsed %d family trees", len(trees))
+
+    # Build ancestry paths for all trees
+    all_paths: dict[str, list[str]] = {}  # glottocode -> path
+    for family_gc, children_of in trees.items():
+        paths = build_ancestry_paths(children_of)
+        all_paths.update(paths)
+
+    logger.info("Built %d ancestry paths", len(all_paths))
+
+    # Now map ISO codes to their tree positions
+    index: dict[str, dict] = {}
+    found = 0
+    missing = 0
+    isolate = 0
+
+    for iso, (gc, family_id) in iso_map.items():
+        if gc in all_paths:
+            path = all_paths[gc]
+            family = path[0]  # root of the tree = top-level family
+            depth = len(path) - 1  # distance from root
+            index[iso] = {
+                "glottocode": gc,
+                "path": path,
+                "family": family,
+                "family_name": gc_names.get(family, family),
+                "depth": depth,
+            }
+            found += 1
+        elif family_id:
+            # Language has a family but isn't in any tree
+            # This can happen for isolates or unclassified languages
+            index[iso] = {
+                "glottocode": gc,
+                "path": [family_id, gc] if family_id != gc else [gc],
+                "family": family_id,
+                "family_name": gc_names.get(family_id, family_id),
+                "depth": 1 if family_id != gc else 0,
+            }
+            found += 1
+            isolate += 1
+        else:
+            # True isolate or unclassified - no family
+            # Check if the glottocode IS a top-level family (isolate families)
+            if gc in trees:
+                index[iso] = {
+                    "glottocode": gc,
+                    "path": [gc],
+                    "family": gc,
+                    "family_name": gc_names.get(gc, gc),
+                    "depth": 0,
+                }
+                found += 1
+                isolate += 1
+            else:
+                missing += 1
+
+    logger.info(
+        "ISO mapping: %d found (%d isolate/fallback), %d missing",
+        found, isolate, missing,
+    )
+
+    return {
+        "languages": index,
+        "family_names": {gc: gc_names.get(gc, gc) for gc in set(
+            info["family"] for info in index.values()
+        )},
+        "stats": {
+            "total_iso_codes": len(iso_map),
+            "mapped": found,
+            "isolate_fallback": isolate,
+            "unmapped": missing,
+            "families_in_nexus": len(trees),
+        },
+    }
+
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(message)s",
+    )
+
+    # Check input files exist
+    for fname in ("languages.csv", "classification.nex"):
+        fpath = GLOTTOLOG_DIR / fname
+        if not fpath.exists():
+            logger.error("Missing: %s — run ingest_glottolog.py first", fpath)
+            sys.exit(1)
+
+    tree_index = build_tree_index()
+
+    # Write output
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(OUTPUT_FILE, "w", encoding="utf-8") as f:
+        json.dump(tree_index, f, ensure_ascii=False, indent=1)
+
+    logger.info("Wrote tree index to %s", OUTPUT_FILE)
+    logger.info("Stats: %s", json.dumps(tree_index["stats"]))
+
+    # Print some sample entries for verification
+    samples = ["eng", "deu", "fra", "spa", "lat", "grc", "hin", "san", "jpn", "tgl"]
+    langs = tree_index["languages"]
+    for iso in samples:
+        if iso in langs:
+            info = langs[iso]
+            path_str = " > ".join(info["path"][-4:])  # last 4 nodes
+            logger.info(
+                "  %s: family=%s, depth=%d, path=...%s",
+                iso, info["family_name"], info["depth"], path_str,
+            )
+
+
+if __name__ == "__main__":
+    main()

scripts/build_phylo_pairs.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+"""Build phylogenetic relationship metadata for cognate pairs.
+
+Cross-references cognate pair language pairs against the Glottolog
+tree index to classify each unique (Lang_A, Lang_B) pair by its
+phylogenetic relationship.
+
+Usage:
+    python scripts/build_phylo_pairs.py
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import logging
+import sys
+from pathlib import Path
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
+
+ROOT = Path(__file__).resolve().parent.parent
+logger = logging.getLogger(__name__)
+
+GLOTTOLOG_DIR = ROOT / "data" / "training" / "raw" / "glottolog_cldf"
+COGNATE_DIR = ROOT / "data" / "training" / "cognate_pairs"
+METADATA_DIR = ROOT / "data" / "training" / "metadata"
+OUTPUT_FILE = METADATA_DIR / "phylo_pairs.tsv"
+
+COGNATE_FILES = [
+    "cognate_pairs_inherited.tsv",
+    "cognate_pairs_borrowing.tsv",
+    "cognate_pairs_similarity.tsv",
+]
+
+# Curated map of attested ancient/medieval languages to the Glottolog clades
+# they are historically ancestral to. Glottocodes verified against Glottolog
+# CLDF v5.x (2026-03-14).
+#
+# Logic: If language A is in this map AND language B's ancestry path passes
+# through one of the listed clades AND B is not itself an ancient language
+# in this map, then the pair is "near_ancestral".
+#
+# Limitation: "Near-ancestral" is approximate — Latin is not literally the
+# ancestor of French (Vulgar Latin, unattested, is). We use it to mean
+# "the attested language is historically ancestral to the clade."
+NEAR_ANCESTOR_MAP: dict[str, list[str]] = {
+    # Latin → Romance
+    "lat": ["roma1334"],
+    # Ancient Greek → Koineic Greek (descendants of Koine)
+    "grc": ["koin1234"],
+    # Sanskrit → Indo-Aryan
+    "san": ["indo1321"],
+    # Old English → Anglic
+    "ang": ["angl1265"],
+    # Middle English → Anglic (more recent ancestor)
+    "enm": ["angl1265"],
+    # Old French → Oil (includes modern French, Picard, etc.)
+    "fro": ["oila1234"],
+    # Old Spanish → Castilic
+    "osp": ["cast1243"],
+    # Old Norse → North Germanic
+    "non": ["nort3160"],
+    # Old High German → High German
+    "goh": ["high1289"],
+    # Middle Dutch → Modern Dutch group
+    "dum": ["mode1257"],
+    # Old Irish → Goidelic
+    "sga": ["goid1240"],
+    # Middle Irish → Goidelic
+    "mga": ["goid1240"],
+    # Old Church Slavonic → South Slavic
+    "chu": ["sout3147"],
+    # Old East Slavic → East Slavic
+    "orv": ["east1426"],
+    # Old Chinese → Classical Chinese (modern Sinitic descends from this)
+    "och": ["clas1255"],
+    # Ottoman Turkish → Oghuz
+    "ota": ["oghu1243"],
+}
+
+# Threshold: MRCA depth >= this value → close_sister, else distant_sister
+CLOSE_SISTER_DEPTH_THRESHOLD = 3
+
+
+def load_tree_index() -> dict:
+    """Load the Glottolog tree index JSON."""
+    tree_file = GLOTTOLOG_DIR / "glottolog_tree.json"
+    with open(tree_file, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def extract_unique_pairs() -> set[tuple[str, str]]:
+    """Extract unique canonically-ordered (Lang_A, Lang_B) pairs from cognate files."""
+    pairs: set[tuple[str, str]] = set()
+    for fname in COGNATE_FILES:
+        fpath = COGNATE_DIR / fname
+        if not fpath.exists():
+            logger.warning("Missing cognate file: %s", fpath)
+            continue
+        with open(fpath, "r", encoding="utf-8") as f:
+            reader = csv.DictReader(f, delimiter="\t")
+            for row in reader:
+                a, b = row["Lang_A"], row["Lang_B"]
+                key = (min(a, b), max(a, b))
+                pairs.add(key)
+        logger.info("After %s: %d unique pairs", fname, len(pairs))
+    return pairs
+
+
+def find_mrca(path_a: list[str], path_b: list[str]) -> tuple[str, int, int]:
+    """Find Most Recent Common Ancestor of two ancestry paths.
+
+    Returns (mrca_glottocode, mrca_depth, tree_distance).
+    Tree distance = edges from A to MRCA + edges from MRCA to B.
+    """
+    # Find longest common prefix
+    mrca_idx = -1
+    min_len = min(len(path_a), len(path_b))
+    for i in range(min_len):
+        if path_a[i] == path_b[i]:
+            mrca_idx = i
+        else:
+            break
+
+    if mrca_idx < 0:
+        # No common ancestor (different top-level families)
+        return ("", 0, 99)
+
+    mrca = path_a[mrca_idx]
+    mrca_depth = mrca_idx  # depth from root (root = 0)
+    dist_a = len(path_a) - 1 - mrca_idx
+    dist_b = len(path_b) - 1 - mrca_idx
+    tree_distance = dist_a + dist_b
+
+    return (mrca, mrca_depth, tree_distance)
+
+
+def check_near_ancestral(
+    iso_a: str,
+    iso_b: str,
+    path_a: list[str],
+    path_b: list[str],
+) -> tuple[bool, str]:
+    """Check if either language is a near-ancestor of the other.
+
+    Returns (is_near_ancestral, ancestor_iso).
+    """
+    # Check if A is in the near-ancestor map
+    if iso_a in NEAR_ANCESTOR_MAP:
+        target_clades = NEAR_ANCESTOR_MAP[iso_a]
+        # Check if B's path passes through any target clade
+        if any(clade in path_b for clade in target_clades):
+            # B must NOT be an ancient language itself
+            if iso_b not in NEAR_ANCESTOR_MAP:
+                return (True, iso_a)
+
+    # Check if B is in the near-ancestor map
+    if iso_b in NEAR_ANCESTOR_MAP:
+        target_clades = NEAR_ANCESTOR_MAP[iso_b]
+        if any(clade in path_a for clade in target_clades):
+            if iso_a not in NEAR_ANCESTOR_MAP:
+                return (True, iso_b)
+
+    return (False, "-")
+
+
+def classify_pair(
+    iso_a: str,
+    iso_b: str,
+    langs: dict,
+    family_names: dict,
+) -> dict:
+    """Classify a single language pair.
+
+    Returns a dict with the TSV row fields.
+    """
+    info_a = langs.get(iso_a)
+    info_b = langs.get(iso_b)
+
+    # Default values
+    result = {
+        "Lang_A": iso_a,
+        "Lang_B": iso_b,
+        "Phylo_Relation": "unclassified",
+        "Tree_Distance": 99,
+        "MRCA_Clade": "-",
+        "MRCA_Depth": 0,
+        "Ancestor_Lang": "-",
+        "Family_A": "-",
+        "Family_B": "-",
+    }
+
+    if not info_a or not info_b:
+        # One or both not in tree
+        if info_a:
+            result["Family_A"] = info_a.get("family_name", "-")
+        if info_b:
+            result["Family_B"] = info_b.get("family_name", "-")
+        return result
+
+    family_a = info_a["family"]
+    family_b = info_b["family"]
+    result["Family_A"] = info_a.get("family_name", family_a)
+    result["Family_B"] = info_b.get("family_name", family_b)
+
+    # Cross-family check
+    if family_a != family_b:
+        result["Phylo_Relation"] = "cross_family"
+        return result
+
+    # Same family — find MRCA
+    path_a = info_a["path"]
+    path_b = info_b["path"]
+
+    mrca, mrca_depth, tree_distance = find_mrca(path_a, path_b)
+    result["Tree_Distance"] = tree_distance
+    result["MRCA_Clade"] = mrca
+    result["MRCA_Depth"] = mrca_depth
+
+    # Check near-ancestral
+    is_near_anc, ancestor = check_near_ancestral(iso_a, iso_b, path_a, path_b)
+    if is_near_anc:
+        result["Phylo_Relation"] = "near_ancestral"
+        result["Ancestor_Lang"] = ancestor
+        return result
+
+    # Sister classification based on MRCA depth
+    if mrca_depth >= CLOSE_SISTER_DEPTH_THRESHOLD:
+        result["Phylo_Relation"] = "close_sister"
+    else:
+        result["Phylo_Relation"] = "distant_sister"
+
+    return result
+
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(message)s",
+    )
+
+    # Check prerequisites
+    tree_file = GLOTTOLOG_DIR / "glottolog_tree.json"
+    if not tree_file.exists():
+        logger.error("Missing: %s — run build_glottolog_tree.py first", tree_file)
+        sys.exit(1)
+
+    logger.info("Loading tree index...")
+    tree_index = load_tree_index()
+    langs = tree_index["languages"]
+    family_names = tree_index.get("family_names", {})
+    logger.info("Loaded %d languages from tree index", len(langs))
+
+    logger.info("Extracting unique pairs from cognate files...")
+    pairs = extract_unique_pairs()
+    logger.info("Total unique pairs: %d", len(pairs))
+
+    logger.info("Classifying pairs...")
+    results = []
+    for i, (a, b) in enumerate(sorted(pairs)):
+        row = classify_pair(a, b, langs, family_names)
+        results.append(row)
+        if (i + 1) % 100000 == 0:
+            logger.info("  Classified %d/%d pairs...", i + 1, len(pairs))
+
+    logger.info("Classification complete. Writing output...")
+
+    # Write TSV
+    METADATA_DIR.mkdir(parents=True, exist_ok=True)
+    columns = [
+        "Lang_A", "Lang_B", "Phylo_Relation", "Tree_Distance",
+        "MRCA_Clade", "MRCA_Depth", "Ancestor_Lang", "Family_A", "Family_B",
+    ]
+    with open(OUTPUT_FILE, "w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=columns, delimiter="\t")
+        writer.writeheader()
+        for row in results:
+            writer.writerow(row)
+
+    logger.info("Wrote %d rows to %s", len(results), OUTPUT_FILE)
+
+    # Print statistics
+    from collections import Counter
+    relation_counts = Counter(r["Phylo_Relation"] for r in results)
+    logger.info("=== Distribution by Phylo_Relation ===")
+    for relation, count in sorted(relation_counts.items(), key=lambda x: -x[1]):
+        pct = 100 * count / len(results)
+        logger.info("  %-18s %7d (%5.1f%%)", relation, count, pct)
+
+    # Count unique families
+    families_a = set(r["Family_A"] for r in results if r["Family_A"] != "-")
+    families_b = set(r["Family_B"] for r in results if r["Family_B"] != "-")
+    all_families = families_a | families_b
+    logger.info("Unique families: %d", len(all_families))
+
+    # Near-ancestral breakdown
+    near_anc = [r for r in results if r["Phylo_Relation"] == "near_ancestral"]
+    if near_anc:
+        anc_counts = Counter(r["Ancestor_Lang"] for r in near_anc)
+        logger.info("=== Near-Ancestral by Ancestor Language ===")
+        for anc, count in sorted(anc_counts.items(), key=lambda x: -x[1]):
+            logger.info("  %s: %d pairs", anc, count)
+
+
+if __name__ == "__main__":
+    main()

scripts/ingest_glottolog.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""Download Glottolog CLDF data for phylogenetic enrichment.
+
+Source: Glottolog CLDF v5.x (Hammarström, Forkel, Haspelmath & Bank)
+URL: https://github.com/glottolog/glottolog-cldf
+License: CC BY 4.0
+Citation: Hammarström et al., DOI: 10.5281/zenodo.15640174
+
+Downloads languages.csv and classification.nex from the CLDF dataset.
+Iron Rule: Data comes from downloaded files. No hardcoded word lists.
+
+Usage:
+    python scripts/ingest_glottolog.py
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import sys
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent
+
+logger = logging.getLogger(__name__)
+
+GLOTTOLOG_DIR = ROOT / "data" / "training" / "raw" / "glottolog_cldf"
+BASE_URL = "https://raw.githubusercontent.com/glottolog/glottolog-cldf/master/cldf/"
+
+FILES = [
+    "languages.csv",
+    "classification.nex",
+]
+
+
+def download_if_needed():
+    """Download Glottolog CLDF files if not cached."""
+    GLOTTOLOG_DIR.mkdir(parents=True, exist_ok=True)
+    for fname in FILES:
+        local = GLOTTOLOG_DIR / fname
+        if local.exists():
+            logger.info("Cached: %s (%d bytes)", fname, local.stat().st_size)
+            continue
+        url = BASE_URL + fname
+        logger.info("Downloading %s ...", url)
+        req = urllib.request.Request(url, headers={
+            "User-Agent": "ancient-scripts-datasets/1.0 (phylo-enrichment)"
+        })
+        with urllib.request.urlopen(req, timeout=120) as resp:
+            data = resp.read()
+        with open(local, "wb") as f:
+            f.write(data)
+        md5 = hashlib.md5(data).hexdigest()
+        logger.info("Downloaded %s (%d bytes, md5=%s)", fname, len(data), md5)
+
+
+def verify_files():
+    """Verify downloaded files exist and have reasonable sizes."""
+    ok = True
+    for fname in FILES:
+        local = GLOTTOLOG_DIR / fname
+        if not local.exists():
+            logger.error("MISSING: %s", local)
+            ok = False
+            continue
+        size = local.stat().st_size
+        if size < 1000:
+            logger.error("TOO SMALL: %s (%d bytes)", fname, size)
+            ok = False
+        else:
+            md5 = hashlib.md5(local.read_bytes()).hexdigest()
+            logger.info("OK: %s (%d bytes, md5=%s)", fname, size, md5)
+    return ok
+
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(message)s",
+    )
+    download_if_needed()
+    if verify_files():
+        logger.info("All Glottolog CLDF files downloaded successfully.")
+    else:
+        logger.error("Some files missing or corrupted.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_phylo_pairs.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""Validate phylo_pairs.tsv with known-answer checks and coverage tests.
+
+Usage:
+    python scripts/validate_phylo_pairs.py
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import json
+import logging
+import random
+import sys
+from collections import Counter
+from pathlib import Path
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
+
+ROOT = Path(__file__).resolve().parent.parent
+logger = logging.getLogger(__name__)
+
+PHYLO_FILE = ROOT / "data" / "training" / "metadata" / "phylo_pairs.tsv"
+TREE_FILE = ROOT / "data" / "training" / "raw" / "glottolog_cldf" / "glottolog_tree.json"
+COGNATE_DIR = ROOT / "data" / "training" / "cognate_pairs"
+
+# Known-answer test cases: (Lang_A, Lang_B, expected_relation, description)
+# Lang_A, Lang_B are alphabetically ordered.
+KNOWN_ANSWER_TESTS = [
+    ("deu", "eng", "close_sister", "both West Germanic"),
+    ("eng", "fra", "distant_sister", "Germanic vs Italic under IE"),
+    ("fra", "lat", "near_ancestral", "Latin is ancestor of French via Romance"),
+    ("lat", "spa", "near_ancestral", "Latin is ancestor of Spanish via Romance"),
+    # Latin and Oscan are in different branches of Italic:
+    # Latin in Latino-Faliscan, Oscan in Sabellic. MRCA=ital1284 at depth 2.
+    ("lat", "osc", "distant_sister", "Latino-Faliscan vs Sabellic under Italic"),
+    ("ang", "eng", "near_ancestral", "Old English is ancestor of English"),
+    ("got", "swe", "distant_sister", "East Germanic vs North Germanic"),
+    ("hin", "san", "near_ancestral", "Sanskrit is ancestor of Hindi via Indo-Aryan"),
+    ("eng", "jpn", "cross_family", "Indo-European vs Japonic"),
+    ("ceb", "tgl", "close_sister", "both Central Philippine under Austronesian"),
+    ("dan", "swe", "close_sister", "both North Germanic"),
+    ("ita", "spa", "close_sister", "both Italo-Western Romance"),
+    ("rus", "ukr", "close_sister", "both East Slavic"),
+]
+
+
+def load_phylo_pairs() -> dict[tuple[str, str], dict]:
+    """Load phylo_pairs.tsv into a lookup dict."""
+    lookup = {}
+    with open(PHYLO_FILE, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+        for row in reader:
+            key = (row["Lang_A"], row["Lang_B"])
+            lookup[key] = row
+    return lookup
+
+
+def test_known_answers(lookup: dict) -> tuple[int, int]:
+    """Run known-answer tests. Returns (passed, total)."""
+    passed = 0
+    total = len(KNOWN_ANSWER_TESTS)
+
+    for lang_a, lang_b, expected, description in KNOWN_ANSWER_TESTS:
+        key = (min(lang_a, lang_b), max(lang_a, lang_b))
+        if key not in lookup:
+            logger.error(
+                "FAIL %s-%s: pair not found in phylo_pairs.tsv (%s)",
+                lang_a, lang_b, description,
+            )
+            continue
+
+        row = lookup[key]
+        actual = row["Phylo_Relation"]
+        if actual == expected:
+            logger.info(
+                "PASS %s-%s: %s (%s)",
+                lang_a, lang_b, actual, description,
+            )
+            passed += 1
+        else:
+            logger.error(
+                "FAIL %s-%s: expected %s, got %s (%s)",
+                lang_a, lang_b, expected, actual, description,
+            )
+
+    return passed, total
+
+
+def test_near_ancestral_integrity(lookup: dict) -> tuple[int, int]:
+    """Verify near_ancestral pairs have valid Ancestor_Lang values."""
+    passed = 0
+    total = 0
+    for key, row in lookup.items():
+        if row["Phylo_Relation"] == "near_ancestral":
+            total += 1
+            anc = row["Ancestor_Lang"]
+            if anc != "-" and anc in (row["Lang_A"], row["Lang_B"]):
+                passed += 1
+            else:
+                logger.error(
+                    "FAIL near_ancestral %s-%s: Ancestor_Lang=%s not in pair",
+                    row["Lang_A"], row["Lang_B"], anc,
+                )
+    return passed, total
+
+
+def test_cross_family_integrity(lookup: dict) -> tuple[int, int]:
+    """Verify cross_family pairs have different families."""
+    passed = 0
+    total = 0
+    for key, row in lookup.items():
+        if row["Phylo_Relation"] == "cross_family":
+            total += 1
+            if row["Family_A"] != row["Family_B"]:
+                passed += 1
+            else:
+                logger.error(
+                    "FAIL cross_family %s-%s: same family %s",
+                    row["Lang_A"], row["Lang_B"], row["Family_A"],
+                )
+    return passed, total
+
+
+def test_coverage(lookup: dict) -> tuple[int, int]:
+    """Verify coverage of cognate pair ISO codes in tree."""
+    tree_file = TREE_FILE
+    with open(tree_file, "r", encoding="utf-8") as f:
+        tree = json.load(f)
+    langs = tree["languages"]
+
+    # Get all ISO codes from cognate pairs
+    cognate_isos = set()
+    for fname in ["cognate_pairs_inherited.tsv", "cognate_pairs_borrowing.tsv",
+                   "cognate_pairs_similarity.tsv"]:
+        fpath = COGNATE_DIR / fname
+        if not fpath.exists():
+            continue
+        with open(fpath, "r", encoding="utf-8") as f:
+            reader = csv.DictReader(f, delimiter="\t")
+            for row in reader:
+                cognate_isos.add(row["Lang_A"])
+                cognate_isos.add(row["Lang_B"])
+
+    in_tree = sum(1 for iso in cognate_isos if iso in langs)
+    pct = 100 * in_tree / len(cognate_isos)
+    logger.info("Coverage: %d/%d ISO codes (%.1f%%)", in_tree, len(cognate_isos), pct)
+
+    if pct >= 95.0:
+        return (1, 1)
+    else:
+        logger.error("Coverage below 95%%: %.1f%%", pct)
+        return (0, 1)
+
+
+def test_random_audit(lookup: dict, n: int = 20) -> tuple[int, int]:
+    """Audit N random pairs by tracing back to tree index."""
+    with open(TREE_FILE, "r", encoding="utf-8") as f:
+        tree = json.load(f)
+    langs = tree["languages"]
+
+    # Select random pairs that are not unclassified
+    classifiable = [
+        (k, v) for k, v in lookup.items()
+        if v["Phylo_Relation"] != "unclassified"
+    ]
+    random.seed(42)  # reproducible
+    samples = random.sample(classifiable, min(n, len(classifiable)))
+
+    passed = 0
+    for (a, b), row in samples:
+        info_a = langs.get(a)
+        info_b = langs.get(b)
+
+        if not info_a or not info_b:
+            logger.error("AUDIT FAIL %s-%s: missing from tree index", a, b)
+            continue
+
+        # Verify families match
+        fam_a_match = info_a.get("family_name", "-") == row["Family_A"]
+        fam_b_match = info_b.get("family_name", "-") == row["Family_B"]
+
+        # Verify same/different family classification
+        same_family = info_a["family"] == info_b["family"]
+        relation = row["Phylo_Relation"]
+        family_consistent = (
+            (relation == "cross_family" and not same_family) or
+            (relation in ("close_sister", "distant_sister", "near_ancestral") and same_family)
+        )
+
+        if fam_a_match and fam_b_match and family_consistent:
+            passed += 1
+        else:
+            logger.error(
+                "AUDIT FAIL %s-%s: fam_a=%s/%s fam_b=%s/%s family_consistent=%s",
+                a, b,
+                info_a.get("family_name"), row["Family_A"],
+                info_b.get("family_name"), row["Family_B"],
+                family_consistent,
+            )
+
+    return passed, n
+
+
+def main():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(message)s",
+    )
+
+    if not PHYLO_FILE.exists():
+        logger.error("Missing: %s — run build_phylo_pairs.py first", PHYLO_FILE)
+        sys.exit(1)
+
+    logger.info("Loading phylo_pairs.tsv...")
+    lookup = load_phylo_pairs()
+    logger.info("Loaded %d pairs", len(lookup))
+
+    all_passed = 0
+    all_total = 0
+
+    # Test 1: Known-answer checks
+    logger.info("")
+    logger.info("=== Test 1: Known-Answer Checks ===")
+    p, t = test_known_answers(lookup)
+    all_passed += p
+    all_total += t
+    logger.info("Known answers: %d/%d passed", p, t)
+
+    # Test 2: Near-ancestral integrity
+    logger.info("")
+    logger.info("=== Test 2: Near-Ancestral Integrity ===")
+    p, t = test_near_ancestral_integrity(lookup)
+    all_passed += p
+    all_total += t
+    logger.info("Near-ancestral integrity: %d/%d passed", p, t)
+
+    # Test 3: Cross-family integrity
+    logger.info("")
+    logger.info("=== Test 3: Cross-Family Integrity ===")
+    p, t = test_cross_family_integrity(lookup)
+    all_passed += p
+    all_total += t
+    logger.info("Cross-family integrity: %d/%d passed", p, t)
+
+    # Test 4: Coverage
+    logger.info("")
+    logger.info("=== Test 4: Coverage Check ===")
+    p, t = test_coverage(lookup)
+    all_passed += p
+    all_total += t
+
+    # Test 5: Random audit
+    logger.info("")
+    logger.info("=== Test 5: Random Audit (20 pairs) ===")
+    p, t = test_random_audit(lookup)
+    all_passed += p
+    all_total += t
+    logger.info("Random audit: %d/%d passed", p, t)
+
+    # Summary
+    logger.info("")
+    logger.info("=" * 50)
+    logger.info("TOTAL: %d/%d tests passed", all_passed, all_total)
+
+    # Distribution summary
+    relation_counts = Counter(v["Phylo_Relation"] for v in lookup.values())
+    logger.info("")
+    logger.info("=== Distribution ===")
+    for relation, count in sorted(relation_counts.items(), key=lambda x: -x[1]):
+        pct = 100 * count / len(lookup)
+        logger.info("  %-18s %7d (%5.1f%%)", relation, count, pct)
+
+    if all_passed == all_total:
+        logger.info("")
+        logger.info("ALL TESTS PASSED")
+        sys.exit(0)
+    else:
+        logger.info("")
+        logger.info("SOME TESTS FAILED")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()