scripts/build.py

# ruff: noqa: T201  # CLI build-script report payload (CLAUDE.md whitelist)
"""Build NuBerea/concept-analysis — consolidated analytical layer for concept topology.

Absorbs all of NuBerea/concept-trajectories and migrates three analytical configs
from NuBerea/concept-graph (community_candidate, community_membership, concept_centroids).

Boundary principle:
  concept-graph   = topology (span_node, span_edge, concept_node, concept_span_edge, ...)
  concept-analysis = derived outputs (centroids, communities, trajectories, drift)

Output configs (20 total, writing 22 parquet dirs — pseu builds write deut+pseu each):
  concept_verse_edge       — 28,909 rows; concept×verse, LXX+NT strata, shlm-grc-en 768-dim
  concept_trajectory       — 112 rows; concept×stratum centroids, LXX+NT
  concept_verse_edge_sp    — 59,478 rows; concept×verse, LXX+NT+Vulgate, SPhilBerta 768-dim
  concept_trajectory_sp    — 190 rows; concept×stratum centroids, LXX+NT+Vulgate
  concept_verse_edge_bt    — 59,478 rows; concept_verse_edge_sp + bt_layer + plate_segment (T8)
  concept_trajectory_bt    — ~960 rows; concept×bt_layer centroids (T8, match_grain=pericope)
  concept_verse_edge_deut  — ~5,857 rows; Deuterocanon verses, nearest-centroid assignment
  concept_verse_edge_pseu  — ~15,043 rows; Pseudepigrapha verses, nearest-centroid assignment
  concept_trajectory_deut  — per-concept centroids for Deuterocanon stratum
  concept_trajectory_pseu  — per-concept centroids for Pseudepigrapha stratum
  concept_drift            — 78 rows; Schlattmann&Vogl 2024 drift metrics per concept×transition
  concept_drift_itp        — 78 rows; PSEU-extended drift (5 pairs: lxx→deut/pseu, deut/pseu→nt, deut→pseu)
  concept_drift_hamilton   — 5,023 rows; Hamilton/CADE word2vec drift per lemma (3 languages)
  community_candidate      — 55 rows; community summaries (from concept-graph)
  community_membership     — 2,412 rows; pericope→community assignments (from concept-graph)
  concept_centroids        — 156 rows; L1+L2 bi_encoder_v1 384-dim centroids (from concept-graph)
  concept_aliases          — 567 rows; TF-IDF English term → bt1_xxx concept_id list mappings
  concept_verse_edge_patr  — ~40K rows; patristic GRC segments, nearest-centroid assignment
  concept_verse_edge_philo — ~7.9K rows; Philo of Alexandria GRC segments, nearest-centroid
  concept_verse_edge_josephus — ~12.7K rows; Josephus GRC segments, nearest-centroid
  concept_verse_edge_targum   — ~28K rows; Targum English translations, nearest-centroid
  concept_verse_edge_talmud   — ~200K rows; Mishnah+Tosefta English translations, nearest-centroid

Source data (local build dirs + HF for HF-native configs):
  huggingface/candidates/build/concept-trajectories/data/
  huggingface/candidates/build/concept-graph/data/
  huggingface/candidates/build/concept-trajectories/data/concept_drift_analysis.csv
  concept_aliases: HF-native — NuBerea/AI-models bi_encoder_v1 + question_bin_assignment.json
                              + NuBerea/concept-graph concept_node centroids
  concept_verse_edge_bt / concept_trajectory_bt: T8 — read NuBerea/pericope-genealogy
    composition_dag (local until genealogy HF upload); promote concept-analysis to T8 for
    bt-indexed configs only.

Usage:
    python scripts/build.py              # build all configs
    python scripts/build.py --config X   # build only config X

For HF-native reproducibility of the trajectory configs, see verify.py in this directory.
"""

from __future__ import annotations

import argparse
import pathlib
import sys

import pandas as pd

BUILD = pathlib.Path("huggingface/candidates/build")
OUT = BUILD / "concept-analysis/data"

# Make hf_registry importable
_THIS = pathlib.Path(__file__).resolve()
_CANDIDATES = _THIS.parents[2]
if str(_CANDIDATES) not in sys.path:
    sys.path.insert(0, str(_CANDIDATES))

from hf_registry import load_hf_or_local


def _parquet_out(config: str) -> pathlib.Path:
    p = OUT / config
    p.mkdir(parents=True, exist_ok=True)
    return p / "train-00000-of-00001.parquet"


def import_trajectory_config(name: str) -> None:
    """Import a trajectory config from NuBerea/concept-trajectories (HF-native, local fallback)."""
    ds = load_hf_or_local("NuBerea/concept-analysis", name)
    df = ds.to_pandas()
    dst = _parquet_out(name)
    df.to_parquet(dst, index=False)
    print(f"  {name}: {len(df):,} rows, {len(df.columns)} cols — imported from NuBerea/concept-trajectories")


def build_concept_drift() -> None:
    """Compute drift inline from concept_trajectory_sp + concept_verse_edge_sp (HF-native)."""
    sys.path.insert(0, str(_THIS.parent))
    from analyze_concept_drift import compute_drift_dataframe

    traj = load_hf_or_local("NuBerea/concept-analysis", "concept_trajectory_sp").to_pandas()
    cve  = load_hf_or_local("NuBerea/concept-analysis", "concept_verse_edge_sp").to_pandas()
    df = compute_drift_dataframe(traj, cve)
    dst = _parquet_out("concept_drift")
    df.to_parquet(dst, index=False)
    print(f"  concept_drift: {len(df)} rows, {len(df.columns)} cols — computed inline (HF-native)")


def import_community_config(name: str) -> None:
    """Import a community config from NuBerea/concept-graph (HF-native, local fallback)."""
    ds = load_hf_or_local("NuBerea/concept-graph", name)
    df = ds.to_pandas()
    dst = _parquet_out(name)
    df.to_parquet(dst, index=False)
    print(f"  {name}: {len(df):,} rows, {len(df.columns)} cols — imported from NuBerea/concept-graph")


def build_concept_centroids() -> None:
    """Build concept_centroids from NuBerea/concept-graph concept_node (HF-native).

    The concept_node config carries each L1/L2 BERTopic node's centroid inline as a
    `centroid` column (bi_encoder_v1 384-dim vectors). We project to a 3-column
    parquet (concept_id, level, centroid) matching the historical schema.
    """
    ds = load_hf_or_local("NuBerea/concept-graph", "concept_node")
    df = ds.to_pandas()
    df = df[df["level"].isin([1, 2])].copy()
    df["level"] = df["level"].map({1: "l1", 2: "l2"})
    df = df[["concept_id", "level", "centroid"]].sort_values(["level", "concept_id"]).reset_index(drop=True)

    dst = _parquet_out("concept_centroids")
    df.to_parquet(dst, index=False)
    per_level = df.groupby("level").size().to_dict()
    print(f"  concept_centroids: {len(df)} rows ({per_level}) — built from concept_node (HF-native)")


def build_concept_drift_hamilton() -> None:
    """Run the Hamilton/CADE word2vec drift analysis (requires gensim).

    Delegates to build_hamilton.py, which trains word2vec per corpus slice,
    aligns via orthogonal Procrustes, and computes drift_score per shared lemma.
    Three independent analyses: Hebrew EBH→LBH, Greek LXX→NT, Latin VG_OT→VG_NT.

    Requires Python 3.12 venv with gensim installed:
        /tmp/gensim_venv/bin/python scripts/build_hamilton.py
    Or equivalently:
        python scripts/build.py --config concept_drift_hamilton
    (which calls build_hamilton.py via subprocess using the same interpreter that
    has gensim, or prints existing stats if the parquet already exists.)
    """
    import subprocess
    import sys

    parquet = OUT / "concept_drift_hamilton" / "train-00000-of-00001.parquet"
    # Try running build_hamilton.py with current interpreter first; fall back to gensim venv
    interpreters = [sys.executable, "/tmp/gensim_venv/bin/python"]
    for interp in interpreters:
        try:
            result = subprocess.run(
                [interp, "scripts/build_hamilton.py"],
                check=True, capture_output=False,
            )
            break
        except (subprocess.CalledProcessError, FileNotFoundError):
            continue
    else:
        if parquet.exists():
            df = pd.read_parquet(parquet)
            print(f"  concept_drift_hamilton: {len(df):,} rows (pre-built; gensim unavailable)")
        else:
            raise RuntimeError(
                "build_hamilton.py failed and no pre-built parquet found. "
                "Run: /tmp/gensim_venv/bin/python scripts/build_hamilton.py"
            )
        return
    df = pd.read_parquet(parquet)
    print(f"  concept_drift_hamilton: {len(df):,} rows — Hamilton/CADE word2vec drift")


def _build_verse_bt_lookup(dag: "pd.DataFrame", nrsv: "pd.DataFrame") -> dict:
    """Return dict mapping OSIS verse ref (dot format) → (bt_layer, plate_segment).

    Covers three node types in composition_dag:
    - otp:/pseu: rows with osis_start/osis_end → range-expanded to constituent verses
    - single-verse rows (unit_id matches 'Book.ch.v') → direct mapping
    """
    import re

    # Parse OSIS ref to (chapter, verse) numeric key for range comparison
    _osis_key_re = re.compile(r'^[^.]+\.(\d+)\.(\d+)$')

    def _key(ref: str) -> tuple[int, int] | None:
        m = _osis_key_re.match(ref)
        if not m:
            return None
        return (int(m.group(1)), int(m.group(2)))

    verse_bt: dict = {}

    # ── 1. Range-based: otp + pseu rows (have osis_start / osis_end) ────────
    range_rows = dag[
        dag['unit_id'].str.startswith(('otp:', 'pseu:'), na=False)
        & dag['osis_start'].ne('')
    ][['osis_start', 'osis_end', 'bt_layer', 'plate_segment']].copy()

    range_rows['_book'] = range_rows['osis_start'].str.split('.').str[0]
    range_rows['_sk'] = range_rows['osis_start'].apply(_key)
    range_rows['_ek'] = range_rows['osis_end'].apply(_key)
    range_rows = range_rows.dropna(subset=['_sk', '_ek'])

    # Build a numeric sort key for merge_asof (ch * 10000 + v fits all Bible ranges)
    range_rows['_start_num'] = range_rows['_sk'].apply(lambda k: k[0] * 10000 + k[1])
    range_rows['_end_num'] = range_rows['_ek'].apply(lambda k: k[0] * 10000 + k[1])

    nrsv_ot = nrsv[nrsv['osis_ref'].str.contains(r'^\w+\.\d+\.\d+$', regex=True, na=False)].copy()
    nrsv_ot['_book'] = nrsv_ot['osis_ref'].str.split('.').str[0]
    nrsv_ot['_num'] = nrsv_ot['osis_ref'].apply(
        lambda r: (lambda k: k[0] * 10000 + k[1] if k else None)(_key(r))
    )
    nrsv_ot = nrsv_ot.dropna(subset=['_num'])
    nrsv_ot['_num'] = nrsv_ot['_num'].astype(int)

    for book, book_perps in range_rows.groupby('_book'):
        book_verses = nrsv_ot[nrsv_ot['_book'] == book][['osis_ref', '_num']].sort_values('_num')
        if book_verses.empty:
            continue
        perps_sorted = book_perps[['_start_num', '_end_num', 'bt_layer', 'plate_segment']].sort_values('_start_num')

        # merge_asof: for each verse, find the last pericope whose start ≤ verse
        merged = pd.merge_asof(
            book_verses,
            perps_sorted,
            left_on='_num',
            right_on='_start_num',
            direction='backward',
        )
        # Keep only verses that also fall before the pericope's end
        merged = merged[merged['_num'] <= merged['_end_num']]
        for _, row in merged.iterrows():
            verse_bt[row['osis_ref']] = (int(row['bt_layer']), str(row['plate_segment']))

    # ── 2. Single-verse nodes: unit_id IS the verse OSIS ref ───────────────
    single_mask = dag['unit_id'].str.match(r'^\w+\.\d+\.\d+$', na=False)
    for _, row in dag[single_mask][['unit_id', 'bt_layer', 'plate_segment']].iterrows():
        verse_bt[row['unit_id']] = (int(row['bt_layer']), str(row['plate_segment']))

    return verse_bt


def _normalize_osis(ref: str) -> str:
    """Convert lxx-style '1Chr 1:1' to OSIS dot-format '1Chr.1.1'."""
    if ' ' in ref:
        book, rest = ref.split(' ', 1)
        return f"{book}.{rest.replace(':', '.')}"
    return ref


def build_concept_verse_edge_bt() -> None:
    """Extend concept_verse_edge_sp with bt_layer and plate_segment from pericope-genealogy.

    Cardinal rule (CLAUDE.md): preserves ALL verse-level rows (match_grain='verse').
    bt_layer is nullable (pd.NA) for NT verses not represented as intertextuality
    anchor nodes in composition_dag. osisRef is the normalized OSIS dot-format ref.

    T8 dependency: reads NuBerea/pericope-genealogy composition_dag (T7). Falls back
    to local build dir until genealogy HF upload is complete.
    """
    import numpy as np

    cve = load_hf_or_local("NuBerea/concept-analysis", "concept_verse_edge_sp").to_pandas()
    dag = load_hf_or_local("NuBerea/analytics", "composition_dag").to_pandas()
    nrsv = load_hf_or_local("NuBerea/nrsv").to_pandas()

    verse_bt = _build_verse_bt_lookup(dag, nrsv)

    # Normalize all osis_refs to dot format for lookup
    cve['osisRef'] = cve['osis_ref'].apply(_normalize_osis)

    bt_layers = []
    plate_segments = []
    for ref in cve['osisRef']:
        val = verse_bt.get(ref)
        if val is not None:
            bt_layers.append(val[0])
            plate_segments.append(val[1])
        else:
            bt_layers.append(pd.NA)
            plate_segments.append(pd.NA)

    cve['bt_layer'] = pd.array(bt_layers, dtype=pd.Int64Dtype())
    cve['plate_segment'] = plate_segments
    cve['match_grain'] = 'verse'

    dst = _parquet_out("concept_verse_edge_bt")
    cve.to_parquet(dst, index=False)
    matched = cve['bt_layer'].notna().sum()
    print(
        f"  concept_verse_edge_bt: {len(cve):,} rows, "
        f"{matched:,} ({100*matched/len(cve):.1f}%) with bt_layer — "
        f"T8 (pericope-genealogy)"
    )


def build_concept_trajectory_bt() -> None:
    """Build concept × bt_layer centroids from concept_verse_edge_bt.

    Cardinal rule: pericope-level derived view (match_grain='pericope') alongside
    concept_trajectory_sp (3-way stratum). Never replaces it.

    Only rows with a non-null bt_layer contribute. Concepts with fewer than 2
    matched verses in a bt_layer are excluded (no meaningful centroid).

    Schema mirrors concept_trajectory_sp with bt_layer replacing stratum, plus
    match_grain='pericope' and osisRef (book prefix of contributing verses).
    """
    import numpy as np

    # Load from local build output (concept_verse_edge_bt must be built first)
    bt_path = _parquet_out("concept_verse_edge_bt")
    if not bt_path.exists():
        raise RuntimeError(
            "concept_verse_edge_bt not found — run build_concept_verse_edge_bt first."
        )
    cve_bt = pd.read_parquet(bt_path)

    # Work only on rows with bt_layer assigned
    matched = cve_bt[cve_bt['bt_layer'].notna()].copy()
    matched['bt_layer'] = matched['bt_layer'].astype(int)

    def _numpy_centroid(embeddings) -> list:
        arr = np.stack([np.asarray(e) for e in embeddings])
        c = arr.mean(axis=0)
        return c.tolist()

    def _mean_cosine(embeddings, centroid) -> float:
        c = np.asarray(centroid)
        sims = []
        for e in embeddings:
            v = np.asarray(e)
            denom = np.linalg.norm(v) * np.linalg.norm(c)
            if denom > 0:
                sims.append(float(np.dot(v, c) / denom))
        return float(np.mean(sims)) if sims else 0.0

    rows = []
    for (concept_id, bt_layer), grp in matched.groupby(['concept_id', 'bt_layer']):
        if len(grp) < 2:
            continue
        embeddings = grp['embedding'].tolist()
        centroid = _numpy_centroid(embeddings)
        rows.append({
            'concept_id': concept_id,
            'concept_label': grp['concept_label'].iloc[0],
            'bt_layer': int(bt_layer),
            'verse_count': len(grp),
            'centroid': centroid,
            'mean_cosine_to_centroid': _mean_cosine(embeddings, centroid),
            'verse_refs': sorted(set(grp['osisRef'].tolist())),
            'model_id': grp['model_id'].iloc[0],
            'match_grain': 'pericope',
        })

    df = pd.DataFrame(rows).sort_values(['concept_id', 'bt_layer']).reset_index(drop=True)
    dst = _parquet_out("concept_trajectory_bt")
    df.to_parquet(dst, index=False)
    print(
        f"  concept_trajectory_bt: {len(df):,} rows "
        f"({df['concept_id'].nunique()} concepts × {df['bt_layer'].nunique()} bt_layers) — "
        f"T8 derived view, match_grain=pericope"
    )


def _build_reference_centroids() -> "tuple[list, list, np.ndarray]":
    """Compute per-concept reference centroids pooled from LXX+NT+VG in SPhilBerta space.

    Returns:
        (concept_ids, concept_labels, centroid_unit_matrix)
        centroid_unit_matrix shape: (n_concepts, 768), L2-normalized rows.
    """
    import numpy as np

    print("  Loading concept_verse_edge_sp for reference centroids...")
    cve_sp = load_hf_or_local("NuBerea/concept-analysis", "concept_verse_edge_sp").to_pandas()

    concept_ids = []
    concept_labels_list = []
    centroid_list = []
    for cid, grp in cve_sp.groupby("concept_id"):
        mats = np.stack([np.asarray(e, dtype=np.float32) for e in grp["embedding"]])
        centroid_list.append(mats.mean(axis=0))
        concept_ids.append(cid)
        concept_labels_list.append(grp["concept_label"].iloc[0])

    centroid_matrix = np.stack(centroid_list)  # (n_concepts, 768)
    norms = np.linalg.norm(centroid_matrix, axis=1, keepdims=True)
    centroid_unit = centroid_matrix / (norms + 1e-8)
    print(f"  Reference space: {len(concept_ids)} concept centroids (768-dim SPhilBerta)")
    return concept_ids, concept_labels_list, centroid_unit


def _project_pseu_stratum(
    stratum: str,
    concept_ids: list,
    concept_labels_list: list,
    centroid_unit: "np.ndarray",
) -> "pd.DataFrame":
    """Project one PSEU stratum onto pre-computed concept centroids.

    Each verse is assigned to its single nearest concept (top-1 cosine similarity).
    assignment_method='nearest_centroid' distinguishes these rows from topology-based
    pericope_containment rows in concept_verse_edge_sp.
    """
    import numpy as np

    config_name = "deut_verse_embeddings_sp" if stratum == "deut" else "pseu_verse_embeddings_sp"
    print(f"  Loading {config_name} from NuBerea/features...")
    pseu_df = load_hf_or_local("NuBerea/features", config_name).to_pandas()
    print(f"  Loaded {len(pseu_df):,} {stratum} verses")

    emb_matrix = np.stack([np.asarray(e, dtype=np.float32) for e in pseu_df["embedding"]])
    emb_norms = np.linalg.norm(emb_matrix, axis=1, keepdims=True)
    emb_unit = emb_matrix / (emb_norms + 1e-8)

    cos_scores = emb_unit @ centroid_unit.T  # (n_verses, n_concepts)
    best_idx = cos_scores.argmax(axis=1)
    best_score = cos_scores[np.arange(len(pseu_df)), best_idx]

    rows = []
    for i, (_, verse_row) in enumerate(pseu_df.iterrows()):
        ci = int(best_idx[i])
        rows.append({
            "concept_id": concept_ids[ci],
            "concept_label": concept_labels_list[ci],
            "osis_ref": verse_row["osis_ref"],
            "stratum": stratum,
            "edge_weight": float(best_score[i]),
            "embedding": verse_row["embedding"],
            "model_id": verse_row["model_id"],
            "assignment_method": "nearest_centroid",
        })

    return pd.DataFrame(rows)


def build_concept_verse_edge_pseu() -> None:
    """Build concept_verse_edge_deut and concept_verse_edge_pseu.

    Both use nearest-centroid projection from the pooled LXX+NT+VG concept
    centroids in SPhilBerta space. PSEU pericopes are not yet represented in
    concept-graph topology, so pericope_containment is not available for these
    strata. assignment_method='nearest_centroid' records this distinction.

    Loads the reference centroid matrix once and reuses it for both strata.
    """
    import numpy as np

    concept_ids, concept_labels_list, centroid_unit = _build_reference_centroids()

    for stratum in ("deut", "pseu"):
        config = f"concept_verse_edge_{stratum}"
        df = _project_pseu_stratum(stratum, concept_ids, concept_labels_list, centroid_unit)
        dst = _parquet_out(config)
        df.to_parquet(dst, index=False)
        concept_count = df["concept_id"].nunique()
        mean_score = df["edge_weight"].mean()
        print(
            f"  {config}: {len(df):,} rows "
            f"({concept_count} unique concepts, mean cosine={mean_score:.4f})"
        )


def build_concept_trajectory_pseu() -> None:
    """Build concept_trajectory_deut and concept_trajectory_pseu.

    Aggregates concept_verse_edge_deut/pseu to per-concept centroids.
    build_concept_verse_edge_pseu must be run first.
    """
    import numpy as np

    for stratum in ("deut", "pseu"):
        edge_path = _parquet_out(f"concept_verse_edge_{stratum}")
        if not edge_path.exists():
            raise RuntimeError(
                f"concept_verse_edge_{stratum} not found — run build_concept_verse_edge_pseu first."
            )
        cve = pd.read_parquet(edge_path)

        rows = []
        for cid, grp in cve.groupby("concept_id"):
            mats = np.stack([np.asarray(e, dtype=np.float32) for e in grp["embedding"]])
            centroid = mats.mean(axis=0)
            cnorm = np.linalg.norm(centroid)
            centroid_unit = centroid / (cnorm + 1e-8)
            norms = np.linalg.norm(mats, axis=1, keepdims=True)
            units = mats / (norms + 1e-8)
            mean_cos = float((units @ centroid_unit).mean())
            rows.append({
                "concept_id": cid,
                "concept_label": grp["concept_label"].iloc[0],
                "stratum": stratum,
                "verse_count": len(grp),
                "centroid": centroid.tolist(),
                "mean_cosine_to_centroid": mean_cos,
                "verse_refs": grp["osis_ref"].tolist(),
                "model_id": grp["model_id"].iloc[0],
                "assignment_method": "nearest_centroid",
            })

        df = pd.DataFrame(rows).sort_values("concept_id").reset_index(drop=True)
        config = f"concept_trajectory_{stratum}"
        dst = _parquet_out(config)
        df.to_parquet(dst, index=False)
        mean_cos_all = df["mean_cosine_to_centroid"].mean()
        print(
            f"  {config}: {len(df):,} rows "
            f"({df['concept_id'].nunique()} concepts, mean coherence={mean_cos_all:.4f})"
        )


def build_concept_drift_pseu() -> None:
    """Compute PSEU-extended drift metrics across 5 new stratum transition pairs.

    Pairs: lxx→deut, lxx→pseu, deut→nt, pseu→nt, deut→pseu.
    Mirrors the Schlattmann & Vogl 2024 methodology used in build_concept_drift(),
    extending to LXX Deuterocanon (stratum 6) and Second Temple Pseudepigrapha (stratum 7).

    Inputs:
      NuBerea/concept-trajectories  concept_trajectory_sp   — lxx/nt/vg centroids
      NuBerea/concept-trajectories  concept_verse_edge_sp   — lxx/nt/vg embeddings
      NuBerea/concept-analysis      concept_trajectory_deut — deut centroids (PSEU)
      NuBerea/concept-analysis      concept_trajectory_pseu — pseu centroids (PSEU)
      NuBerea/concept-analysis      concept_verse_edge_deut — deut embeddings (PSEU)
      NuBerea/concept-analysis      concept_verse_edge_pseu — pseu embeddings (PSEU)

    Output: 78 rows (one per concept); wide format with per-stratum crystallization
    and per-pair cross-stratum drift metrics.
    """
    import numpy as np
    sys.path.insert(0, str(_THIS.parent))
    from analyze_concept_drift import cosine_sim, cross_density

    traj_sp   = load_hf_or_local("NuBerea/concept-analysis", "concept_trajectory_sp").to_pandas()
    traj_deut = load_hf_or_local("NuBerea/concept-analysis", "concept_trajectory_deut").to_pandas()
    traj_pseu = load_hf_or_local("NuBerea/concept-analysis", "concept_trajectory_pseu").to_pandas()
    traj_all  = pd.concat([traj_sp, traj_deut, traj_pseu], ignore_index=True)
    traj_idx  = traj_all.set_index(["concept_id", "stratum"])

    cve_sp   = load_hf_or_local("NuBerea/concept-analysis", "concept_verse_edge_sp").to_pandas()
    cve_deut = load_hf_or_local("NuBerea/concept-analysis", "concept_verse_edge_deut").to_pandas()
    cve_pseu = load_hf_or_local("NuBerea/concept-analysis", "concept_verse_edge_pseu").to_pandas()
    cve_all  = pd.concat([cve_sp, cve_deut, cve_pseu], ignore_index=True)

    emb_index: dict[tuple, np.ndarray] = {}
    for (cid, stratum), grp in cve_all.groupby(["concept_id", "stratum"]):
        emb_index[(cid, stratum)] = np.stack(
            [np.array(e, dtype=np.float32) for e in grp["embedding"]]
        )

    all_concepts = traj_sp["concept_id"].unique()
    concept_label = (
        traj_sp.drop_duplicates("concept_id")
        .set_index("concept_id")["concept_label"]
        .to_dict()
    )

    pseu_pairs = [
        ("lxx", "deut"), ("lxx", "pseu"),
        ("deut", "nt"), ("pseu", "nt"),
        ("deut", "pseu"),
    ]
    all_strata = ["lxx", "nt", "vg", "deut", "pseu"]

    records = []
    for cid in all_concepts:
        label = concept_label.get(cid, "")
        row: dict = {"concept_id": cid, "concept_label": label}

        for s in all_strata:
            key = (cid, s)
            if key in traj_idx.index:
                row[f"verse_count_{s}"]     = int(traj_idx.loc[key, "verse_count"])
                row[f"crystallization_{s}"] = float(traj_idx.loc[key, "mean_cosine_to_centroid"])
                row[f"dispersion_{s}"]      = 1.0 - row[f"crystallization_{s}"]
            else:
                row[f"verse_count_{s}"]     = 0
                row[f"crystallization_{s}"] = float("nan")
                row[f"dispersion_{s}"]      = float("nan")

        for s_a, s_b in pseu_pairs:
            tag   = f"{s_a}_{s_b}"
            key_a = (cid, s_a)
            key_b = (cid, s_b)
            have_a = key_a in traj_idx.index
            have_b = key_b in traj_idx.index

            if have_a and have_b:
                c_a = np.array(traj_idx.loc[key_a, "centroid"], dtype=np.float32)
                c_b = np.array(traj_idx.loc[key_b, "centroid"], dtype=np.float32)
                cc  = cosine_sim(c_a, c_b)
                row[f"centroid_cosine_{tag}"] = cc
                row[f"centroid_drift_{tag}"]  = 1.0 - cc
            else:
                row[f"centroid_cosine_{tag}"] = float("nan")
                row[f"centroid_drift_{tag}"]  = float("nan")

            d_a = row[f"dispersion_{s_a}"]
            d_b = row[f"dispersion_{s_b}"]
            row[f"delta_dispersion_{tag}"] = (
                d_b - d_a
                if (not np.isnan(d_a) and not np.isnan(d_b))
                else float("nan")
            )

            if have_a and key_b in emb_index:
                c_a   = np.array(traj_idx.loc[key_a, "centroid"], dtype=np.float32)
                emb_b = emb_index[key_b]
                cd_ab = cross_density(emb_b, c_a)
                row[f"cross_density_{tag}"] = cd_ab
                row[f"cross_drift_{tag}"]   = 1.0 - cd_ab
            else:
                row[f"cross_density_{tag}"] = float("nan")
                row[f"cross_drift_{tag}"]   = float("nan")

            if have_b and key_a in emb_index:
                c_b   = np.array(traj_idx.loc[key_b, "centroid"], dtype=np.float32)
                emb_a = emb_index[key_a]
                row[f"cross_density_{s_b}_{s_a}"] = cross_density(emb_a, c_b)
            else:
                row[f"cross_density_{s_b}_{s_a}"] = float("nan")

            cd_tag = row[f"centroid_drift_{tag}"]
            xd_tag = row[f"cross_drift_{tag}"]
            both_ok = not np.isnan(cd_tag) and not np.isnan(xd_tag)
            row[f"drift_score_{tag}"] = (cd_tag + xd_tag) / 2.0 if both_ok else float("nan")

        records.append(row)

    df = pd.DataFrame(records)
    dst = _parquet_out("concept_drift_itp")
    df.to_parquet(dst, index=False)
    print(f"  concept_drift_itp: {len(df)} rows, {len(df.columns)} cols — 5 PSEU drift pairs (lxx→deut/pseu, deut/pseu→nt, deut→pseu)")


def build_concept_aliases() -> None:
    """Build concept_aliases (TF-IDF English term → bt1_xxx mapping) from HF inputs.

    Fully HF-native: loads bi_encoder_v1 + question_bin_assignment.json from
    NuBerea/AI-models and L1 centroids from NuBerea/concept-graph, then runs the
    BERTopic alias TF-IDF logic. See build_aliases_from_hf.py for details.
    """
    from build_aliases_from_hf import build_aliases_dataframe

    df = build_aliases_dataframe()
    dst = _parquet_out("concept_aliases")
    df.to_parquet(dst, index=False)
    print(f"  concept_aliases: {len(df)} rows, {len(df.columns)} cols — built HF-native")


def build_concept_verse_edge_patr() -> None:
    """Project patristic GRC segments onto concept centroids via nearest-centroid assignment.

    Loads pre-computed SPhilBerta embeddings from NuBerea/features
    (patr_grc_embeddings_sp, ~40K rows) and assigns each segment to its
    nearest concept from the pooled LXX+NT+VG reference centroids.

    Output schema matches concept_verse_edge_pseu but uses `segment_id` instead
    of `osis_ref` and adds `cts_urn`, `author_label`, and `family_id` fields
    for downstream patristic-specific joins.
    """
    import numpy as np

    concept_ids, concept_labels_list, centroid_unit = _build_reference_centroids()

    print("  Loading patristics embeddings from NuBerea/features (patr_grc_embeddings_sp)...")
    patr_df = load_hf_or_local("NuBerea/features", "patr_grc_embeddings_sp").to_pandas()
    print(f"  Loaded {len(patr_df):,} patristic GRC segments")

    emb_matrix = np.stack([np.asarray(e, dtype=np.float32) for e in patr_df["embedding"]])
    emb_norms = np.linalg.norm(emb_matrix, axis=1, keepdims=True)
    emb_unit = emb_matrix / (emb_norms + 1e-8)

    cos_scores = emb_unit @ centroid_unit.T  # (n_segments, n_concepts)
    best_idx = cos_scores.argmax(axis=1)
    best_score = cos_scores[np.arange(len(patr_df)), best_idx]

    rows = []
    for i, (_, seg_row) in enumerate(patr_df.iterrows()):
        ci = int(best_idx[i])
        rows.append({
            "concept_id": concept_ids[ci],
            "concept_label": concept_labels_list[ci],
            "segment_id": seg_row["segment_id"],
            "cts_urn": seg_row["cts_urn"],
            "author_label": seg_row["author_label"],
            "family_id": seg_row["family_id"],
            "stratum": "patr",
            "edge_weight": float(best_score[i]),
            "embedding": seg_row["embedding"],
            "model_id": seg_row["model_id"],
            "assignment_method": "nearest_centroid",
        })

    df = pd.DataFrame(rows)
    dst = _parquet_out("concept_verse_edge_patr")
    df.to_parquet(dst, index=False)
    concept_count = df["concept_id"].nunique()
    mean_score = df["edge_weight"].mean()
    print(
        f"  concept_verse_edge_patr: {len(df):,} rows "
        f"({concept_count} unique concepts, mean cosine={mean_score:.4f}, "
        f"{df['family_id'].nunique()} families)"
    )


_TARGUM_OSIS_MAP: dict[str, str] = {
    # Torah
    "Genesis": "Gen", "Exodus": "Exod", "Leviticus": "Lev",
    "Numbers": "Num", "Deuteronomy": "Deut",
    # Former Prophets
    "Joshua": "Josh", "Judges": "Judg", "Ruth": "Ruth",
    "I Samuel": "1Sam", "II Samuel": "2Sam",
    "I Kings": "1Kgs", "II Kings": "2Kgs",
    # Latter Prophets
    "Isaiah": "Isa", "Jeremiah": "Jer", "Ezekiel": "Ezek",
    "Hosea": "Hos", "Joel": "Joel", "Amos": "Amos", "Obadiah": "Obad",
    "Jonah": "Jonah", "Micah": "Mic", "Nahum": "Nah", "Habakkuk": "Hab",
    "Zephaniah": "Zeph", "Haggai": "Hag", "Zechariah": "Zech", "Malachi": "Mal",
    # Writings
    "Psalms": "Ps", "Proverbs": "Prov", "Job": "Job",
    "Song of Songs": "Song", "Lamentations": "Lam", "Ecclesiastes": "Eccl",
    "Esther": "Esth", "Daniel": "Dan", "Ezra": "Ezra", "Nehemiah": "Neh",
    "I Chronicles": "1Chr", "II Chronicles": "2Chr",
}


def _embed_texts_sphilberta(texts: list[str], batch_size: int = 32) -> tuple:
    """Embed texts with SPhilBerta. Returns (vecs: np.ndarray float32, model_id: str)."""
    from sentence_transformers import SentenceTransformer
    import torch

    model_id = "bowphs/SPhilBerta"
    if torch.backends.mps.is_available():
        device = "mps"
    elif torch.cuda.is_available():
        device = "cuda"
    else:
        device = "cpu"
    print(f"    Loading {model_id} on {device}...")
    model = SentenceTransformer(model_id, device=device)
    print(f"    Embedding {len(texts):,} texts (batch_size={batch_size})...")
    vecs = model.encode(
        texts,
        batch_size=batch_size,
        show_progress_bar=True,
        normalize_embeddings=False,
        convert_to_numpy=True,
    )
    return vecs.astype("float32"), model_id


def build_concept_verse_edge_philo() -> None:
    """Project Philo of Alexandria GRC segments onto concept centroids.

    Loads philo_grc from NuBerea/secondary-sources (7,906 rows), embeds with
    SPhilBerta, and assigns each segment to its nearest concept centroid.
    Schema mirrors concept_verse_edge_patr.
    """
    import numpy as np

    concept_ids, concept_labels_list, centroid_unit = _build_reference_centroids()

    print("  Loading philo_grc from NuBerea/secondary-sources...")
    philo_df = load_hf_or_local("NuBerea/secondary-sources", "philo_grc").to_pandas()
    print(f"  Loaded {len(philo_df):,} Philo segments")

    vecs, model_id = _embed_texts_sphilberta(philo_df["text"].tolist())

    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
    vecs_unit = vecs / (norms + 1e-8)
    cos_scores = vecs_unit @ centroid_unit.T
    best_idx = cos_scores.argmax(axis=1)
    best_score = cos_scores[np.arange(len(philo_df)), best_idx]

    rows = []
    for i, (_, seg) in enumerate(philo_df.iterrows()):
        ci = int(best_idx[i])
        rows.append({
            "concept_id": concept_ids[ci],
            "concept_label": concept_labels_list[ci],
            "segment_id": seg["segment_id"],
            "cts_urn": seg["cts_urn"],
            "author_label": seg["author_label"],
            "work_label": seg["work_label"],
            "stratum": "philo",
            "edge_weight": float(best_score[i]),
            "embedding": vecs[i],
            "model_id": model_id,
            "assignment_method": "nearest_centroid",
        })

    df = pd.DataFrame(rows)
    dst = _parquet_out("concept_verse_edge_philo")
    df.to_parquet(dst, index=False)
    concept_count = df["concept_id"].nunique()
    mean_score = df["edge_weight"].mean()
    print(
        f"  concept_verse_edge_philo: {len(df):,} rows "
        f"({concept_count} unique concepts, mean cosine={mean_score:.4f})"
    )


def build_concept_verse_edge_josephus() -> None:
    """Project Josephus GRC segments onto concept centroids.

    Loads josephus_grc from NuBerea/secondary-sources (12,735 rows), embeds with
    SPhilBerta, and assigns each segment to its nearest concept centroid.
    """
    import numpy as np

    concept_ids, concept_labels_list, centroid_unit = _build_reference_centroids()

    print("  Loading josephus_grc from NuBerea/secondary-sources...")
    jos_df = load_hf_or_local("NuBerea/secondary-sources", "josephus_grc").to_pandas()
    print(f"  Loaded {len(jos_df):,} Josephus segments")

    vecs, model_id = _embed_texts_sphilberta(jos_df["text"].tolist())

    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
    vecs_unit = vecs / (norms + 1e-8)
    cos_scores = vecs_unit @ centroid_unit.T
    best_idx = cos_scores.argmax(axis=1)
    best_score = cos_scores[np.arange(len(jos_df)), best_idx]

    rows = []
    for i, (_, seg) in enumerate(jos_df.iterrows()):
        ci = int(best_idx[i])
        rows.append({
            "concept_id": concept_ids[ci],
            "concept_label": concept_labels_list[ci],
            "segment_id": seg["segment_id"],
            "cts_urn": seg["cts_urn"],
            "author_label": seg["author_label"],
            "work_label": seg["work_label"],
            "stratum": "josephus",
            "edge_weight": float(best_score[i]),
            "embedding": vecs[i],
            "model_id": model_id,
            "assignment_method": "nearest_centroid",
        })

    df = pd.DataFrame(rows)
    dst = _parquet_out("concept_verse_edge_josephus")
    df.to_parquet(dst, index=False)
    concept_count = df["concept_id"].nunique()
    mean_score = df["edge_weight"].mean()
    print(
        f"  concept_verse_edge_josephus: {len(df):,} rows "
        f"({concept_count} unique concepts, mean cosine={mean_score:.4f})"
    )


def build_concept_verse_edge_targum() -> None:
    """Project Targum (Aramaic OT paraphrase) English translations onto concept centroids.

    Loads targum config from NuBerea/second-temple (~28K rows), embeds text_en
    with SPhilBerta (Aramaic is unvalidated; English preserves interpretive content),
    and assigns each verse to its nearest concept centroid. Derives canonical osis_ref
    from book + section_0 (chapter) + section_1 (verse) for downstream pericope joins.
    """
    import numpy as np

    concept_ids, concept_labels_list, centroid_unit = _build_reference_centroids()

    print("  Loading targum from NuBerea/second-temple...")
    tg_df = load_hf_or_local("NuBerea/second-temple", "targum").to_pandas()
    print(f"  Loaded {len(tg_df):,} Targum rows")

    # Drop rows with no English translation
    tg_df = tg_df[tg_df["text_en"].notna() & (tg_df["text_en"].str.strip() != "")].copy()
    print(f"  {len(tg_df):,} rows with text_en available")

    texts = tg_df["text_en"].tolist()
    vecs, model_id = _embed_texts_sphilberta(texts)

    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
    vecs_unit = vecs / (norms + 1e-8)
    cos_scores = vecs_unit @ centroid_unit.T
    best_idx = cos_scores.argmax(axis=1)
    best_score = cos_scores[np.arange(len(tg_df)), best_idx]

    def _osis_book_from_targum(book: str, targum_name: str | None) -> str | None:
        osis = _TARGUM_OSIS_MAP.get(book)
        if osis:
            return osis
        # book is typically "{targum_name} {canonical_name}" — strip the prefix
        prefix = (targum_name or "").strip()
        if prefix and book.startswith(prefix + " "):
            osis = _TARGUM_OSIS_MAP.get(book[len(prefix) + 1:])
        if osis:
            return osis
        # Fallback: try each word-count suffix (handles unexpected prefix variants)
        words = book.split()
        for skip in range(1, len(words)):
            osis = _TARGUM_OSIS_MAP.get(" ".join(words[skip:]))
            if osis:
                return osis
        return None

    rows = []
    for i, (_, seg) in enumerate(tg_df.iterrows()):
        ci = int(best_idx[i])
        book = seg.get("book") or ""
        targum_name = seg.get("targum_name")
        osis_book = _osis_book_from_targum(book, targum_name)
        s0 = seg.get("section_0")
        s1 = seg.get("section_1")
        if osis_book and s0 is not None and s1 is not None:
            osis_ref = f"{osis_book}.{int(s0) + 1}.{int(s1) + 1}"
        elif osis_book and s0 is not None:
            osis_ref = f"{osis_book}.{int(s0) + 1}"
        else:
            osis_ref = None
        rows.append({
            "concept_id": concept_ids[ci],
            "concept_label": concept_labels_list[ci],
            "segment_id": seg["segment_id"],
            "osis_ref": osis_ref,
            "targum_name": seg.get("targum_name"),
            "section": seg.get("section"),
            "book": book,
            "stratum": "targum",
            "edge_weight": float(best_score[i]),
            "embedding": vecs[i],
            "model_id": model_id,
            "assignment_method": "nearest_centroid",
        })

    df = pd.DataFrame(rows)
    dst = _parquet_out("concept_verse_edge_targum")
    df.to_parquet(dst, index=False)
    concept_count = df["concept_id"].nunique()
    mean_score = df["edge_weight"].mean()
    osis_coverage = df["osis_ref"].notna().mean()
    print(
        f"  concept_verse_edge_targum: {len(df):,} rows "
        f"({concept_count} unique concepts, mean cosine={mean_score:.4f}, "
        f"osis_ref coverage={osis_coverage:.1%})"
    )


def build_concept_verse_edge_talmud() -> None:
    """Project Talmud English translations onto concept centroids.

    Reads mishnah and tosefta directly from NuBerea/talmud via HfFileSystem
    (load_dataset fails on this repo; parquets are read directly). Bavli and
    yerushalmi are skipped until their parquets are uploaded. Embeds text_en
    with SPhilBerta (Mishnaic Hebrew and Talmudic Aramaic are unembeddable
    directly; English translations preserve interpretive content).

    Stratum values: mishnah (~200 CE), tosefta (~220 CE).
    """
    import numpy as np
    from huggingface_hub import HfFileSystem

    concept_ids, concept_labels_list, centroid_unit = _build_reference_centroids()

    fs = HfFileSystem()
    _TALMUD_PATHS = [
        ("datasets/NuBerea/talmud/data/mishnah/train-00000-of-00001.parquet", "mishnah"),
        ("datasets/NuBerea/talmud/data/tosefta/train-00000-of-00001.parquet", "tosefta"),
    ]

    all_dfs: list[pd.DataFrame] = []
    for hf_path, stratum in _TALMUD_PATHS:
        try:
            df = pd.read_parquet(fs.open(hf_path))
        except Exception as e:  # noqa: BLE001  best-effort catch (logs/records)
            print(f"  Skipping talmud/{stratum}: {e}")
            continue
        if len(df) == 0:
            print(f"  Skipping talmud/{stratum}: empty")
            continue
        total = len(df)
        df = df[df["text_en"].notna() & (df["text_en"].str.strip() != "")].copy()
        df["_stratum"] = stratum
        print(f"  talmud/{stratum}: {len(df):,} rows with text_en (of {total:,} total)")
        all_dfs.append(df)

    if not all_dfs:
        print("  No Talmud data available — skipping")
        return

    combined = pd.concat(all_dfs, ignore_index=True)
    print(f"  Total: {len(combined):,} Talmud rows across {len(all_dfs)} config(s)")

    texts = combined["text_en"].tolist()
    vecs, model_id = _embed_texts_sphilberta(texts, batch_size=128)

    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
    vecs_unit = vecs / (norms + 1e-8)
    cos_scores = vecs_unit @ centroid_unit.T
    best_idx = cos_scores.argmax(axis=1)
    best_score = cos_scores[np.arange(len(combined)), best_idx]

    rows = []
    for i, (_, seg) in enumerate(combined.iterrows()):
        ci = int(best_idx[i])
        rows.append({
            "concept_id":        concept_ids[ci],
            "concept_label":     concept_labels_list[ci],
            "segment_id":        seg["segment_id"],
            "ref":               seg.get("ref"),
            "title":             seg.get("title"),
            "tractate":          seg.get("tractate"),
            "order":             seg.get("order"),
            "stratum":           seg["_stratum"],
            "edge_weight":       float(best_score[i]),
            "embedding":         vecs[i],
            "model_id":          model_id,
            "assignment_method": "nearest_centroid",
        })

    df_out = pd.DataFrame(rows)
    dst = _parquet_out("concept_verse_edge_talmud")
    df_out.to_parquet(dst, index=False)
    concept_count = df_out["concept_id"].nunique()
    mean_score = df_out["edge_weight"].mean()
    strata = df_out["stratum"].value_counts().to_dict()
    print(
        f"  concept_verse_edge_talmud: {len(df_out):,} rows "
        f"({concept_count} unique concepts, mean cosine={mean_score:.4f})"
    )
    print(f"  Strata: {strata}")


def build_concept_verse_edge_nhc() -> None:
    """Project Nag Hammadi Corpus segments onto concept centroids.

    Reuses pre-computed SPhilBerta embeddings from NuBerea/features →
    gnostic_ln_bridge rather than re-running inference.  The embedding
    column is a 768-dim float32 vector already L2-normalised at build time.
    """
    import numpy as np
    from datasets import load_dataset

    concept_ids, concept_labels_list, centroid_unit = _build_reference_centroids()

    ds = load_dataset("NuBerea/features", "gnostic_ln_bridge", split="train")
    df = ds.to_pandas()

    emb_col = df["embedding"].tolist()
    vecs = np.array(emb_col, dtype=np.float32)
    norms = np.linalg.norm(vecs, axis=1, keepdims=True)
    vecs_unit = vecs / (norms + 1e-8)

    cos_scores = vecs_unit @ centroid_unit.T
    best_idx   = cos_scores.argmax(axis=1)
    best_score = cos_scores[np.arange(len(df)), best_idx]

    rows = []
    for i, (_, seg) in enumerate(df.iterrows()):
        ci = int(best_idx[i])
        rows.append({
            "concept_id":        concept_ids[ci],
            "concept_label":     concept_labels_list[ci],
            "segment_id":        seg["segment_id"],
            "codex":             seg.get("codex"),
            "tractate_num":      seg.get("tractate_num"),
            "work_slug":         seg.get("work_slug"),
            "work_title":        seg.get("work_title"),
            "stratum":           "nhc",
            "edge_weight":       float(best_score[i]),
            "embedding":         vecs[i],
            "model_id":          "bowphs/SPhilBerta",
            "assignment_method": "nearest_centroid",
        })

    df_out = pd.DataFrame(rows)
    dst = _parquet_out("concept_verse_edge_nhc")
    df_out.to_parquet(dst, index=False)
    concept_count = df_out["concept_id"].nunique()
    mean_score    = df_out["edge_weight"].mean()
    print(
        f"  concept_verse_edge_nhc: {len(df_out):,} rows "
        f"({concept_count} unique concepts, mean cosine={mean_score:.4f})"
    )


# ──────────────────────────────────────────────────────────────────────────────
# concept_trajectory_series + concept_drift_sequential
# Corpus-timeline view: per-concept centroids across 11 strata in temporal order
# (OT-LXX → PSEU → Philo/Josephus → NT → Patristics → Targum/Mishnah/Tosefta → VG)
# ──────────────────────────────────────────────────────────────────────────────

_SERIES_STRATA = [
    # (stratum_name, stratum_order, language, edge_config, stratum_filter)
    # stratum_filter: column value to select when one config covers multiple strata
    ("lxx",      1,  "grc", "concept_verse_edge_sp",       "lxx"),
    ("deut",     2,  "grc", "concept_verse_edge_deut",     None),
    ("pseu",     3,  "grc", "concept_verse_edge_pseu",     None),
    ("philo",    4,  "grc", "concept_verse_edge_philo",    None),
    ("nt",       5,  "grc", "concept_verse_edge_sp",       "nt"),
    ("josephus", 6,  "grc", "concept_verse_edge_josephus", None),
    ("patr",     7,  "grc", "concept_verse_edge_patr",     None),
    ("targum",   8,  "en",  "concept_verse_edge_targum",   None),
    ("mishnah",  9,  "en",  "concept_verse_edge_talmud",   "mishnah"),
    ("tosefta",  10, "en",  "concept_verse_edge_talmud",   "tosefta"),
    ("vg",       11, "lat", "concept_verse_edge_sp",       "vg"),
]

_SERIES_PAIRS = [
    # (stratum_a, stratum_b, pair_order)
    # patr→targum (pair 7) and tosefta→vg (pair 10) are cross-language
    ("lxx",      "deut",      1),
    ("deut",     "pseu",      2),
    ("pseu",     "philo",     3),
    ("philo",    "nt",        4),
    ("nt",       "josephus",  5),
    ("josephus", "patr",      6),
    ("patr",     "targum",    7),
    ("targum",   "mishnah",   8),
    ("mishnah",  "tosefta",   9),
    ("tosefta",  "vg",       10),
]


def build_concept_trajectory_series() -> None:
    """Per-concept centroids across all 11 strata in temporal order.

    Long format: ~858 rows (78 concepts × up to 11 strata).
    Crystallization = mean cosine of member embeddings to their own per-stratum centroid.
    mean_edge_weight = mean cosine to the reference centroid (pooled LXX+NT+VG).

    Strata with no segments for a concept are omitted (so row count may be <858).
    concept_verse_edge_sp is loaded once and reused for lxx, nt, vg strata.
    concept_verse_edge_talmud is loaded once and reused for mishnah, tosefta strata.
    """
    import numpy as np

    _cache: dict[str, pd.DataFrame] = {}
    all_rows: list[dict] = []

    for stratum, stratum_order, language, edge_config, stratum_filter in _SERIES_STRATA:
        print(f"  [{stratum_order}/11] {stratum} ← {edge_config}...")
        if edge_config not in _cache:
            _cache[edge_config] = load_hf_or_local(
                "NuBerea/concept-analysis", edge_config
            ).to_pandas()
        df = _cache[edge_config].copy()

        if stratum_filter is not None:
            df = df[df["stratum"] == stratum_filter]

        if len(df) == 0:
            print(f"    Skipping {stratum}: no rows")
            continue

        model_id = str(df["model_id"].iloc[0]) if "model_id" in df.columns else "SPhilBerta"

        for cid, grp in df.groupby("concept_id"):
            embs = np.stack([np.asarray(e, dtype=np.float32) for e in grp["embedding"]])

            centroid = embs.mean(axis=0)
            cnorm = np.linalg.norm(centroid)
            centroid_unit = centroid / (cnorm + 1e-8)

            norms = np.linalg.norm(embs, axis=1, keepdims=True)
            units = embs / (norms + 1e-8)
            crystallization = float((units @ centroid_unit).mean())

            all_rows.append({
                "concept_id":       cid,
                "concept_label":    grp["concept_label"].iloc[0],
                "stratum":          stratum,
                "stratum_order":    stratum_order,
                "language":         language,
                "verse_count":      len(grp),
                "mean_edge_weight": float(grp["edge_weight"].mean()),
                "crystallization":  crystallization,
                "centroid":         centroid.tolist(),
                "model_id":         model_id,
            })

        n_concepts = df["concept_id"].nunique()
        print(f"    {stratum}: {len(df):,} segments → {n_concepts} concept groups")

    result = (
        pd.DataFrame(all_rows)
        .sort_values(["concept_id", "stratum_order"])
        .reset_index(drop=True)
    )
    dst = _parquet_out("concept_trajectory_series")
    result.to_parquet(dst, index=False)
    print(
        f"  concept_trajectory_series: {len(result):,} rows "
        f"({result['concept_id'].nunique()} concepts × "
        f"{result['stratum'].nunique()} strata)"
    )


def build_concept_drift_sequential() -> None:
    """Adjacent-pair drift across the 11-stratum corpus timeline.

    Reads concept_trajectory_series (must be built first).
    Outputs ~780 rows (78 concepts × 10 adjacent pairs).
    same_language=False marks cross-language pairs (patr→targum, tosefta→vg)
    where centroid_drift is confounded by model-language mismatch.

    centroid_drift = 1 − cosine(centroid_a, centroid_b); range [0, 2].
    delta_crystallization = crystallization_b − crystallization_a.
    delta_mean_edge_weight = mean_edge_weight_b − mean_edge_weight_a.
    """
    import numpy as np

    series_path = _parquet_out("concept_trajectory_series")
    if not series_path.exists():
        raise RuntimeError(
            "concept_trajectory_series not found — "
            "run build_concept_trajectory_series first."
        )

    traj = pd.read_parquet(series_path)
    traj_idx = traj.set_index(["concept_id", "stratum"])
    lang_map = traj.drop_duplicates("stratum").set_index("stratum")["language"].to_dict()
    concept_ids = traj["concept_id"].unique()

    all_rows: list[dict] = []
    for stratum_a, stratum_b, pair_order in _SERIES_PAIRS:
        lang_a = lang_map.get(stratum_a, "?")
        lang_b = lang_map.get(stratum_b, "?")

        for cid in concept_ids:
            try:
                row_a = traj_idx.loc[(cid, stratum_a)]
                row_b = traj_idx.loc[(cid, stratum_b)]
            except KeyError:
                continue

            c_a = np.asarray(row_a["centroid"], dtype=np.float32)
            c_b = np.asarray(row_b["centroid"], dtype=np.float32)
            c_a_u = c_a / (np.linalg.norm(c_a) + 1e-8)
            c_b_u = c_b / (np.linalg.norm(c_b) + 1e-8)
            cos_sim = float(np.dot(c_a_u, c_b_u))

            all_rows.append({
                "concept_id":             cid,
                "concept_label":          row_a["concept_label"],
                "stratum_a":              stratum_a,
                "stratum_b":              stratum_b,
                "pair_order":             pair_order,
                "language_a":             lang_a,
                "language_b":             lang_b,
                "same_language":          lang_a == lang_b,
                "centroid_cosine":        cos_sim,
                "centroid_drift":         1.0 - cos_sim,
                "delta_crystallization":  float(row_b["crystallization"] - row_a["crystallization"]),
                "delta_mean_edge_weight": float(row_b["mean_edge_weight"] - row_a["mean_edge_weight"]),
            })

    result = (
        pd.DataFrame(all_rows)
        .sort_values(["concept_id", "pair_order"])
        .reset_index(drop=True)
    )
    dst = _parquet_out("concept_drift_sequential")
    result.to_parquet(dst, index=False)
    n_pairs = result["pair_order"].nunique()
    same_lang_count = int(result["same_language"].sum())
    print(
        f"  concept_drift_sequential: {len(result):,} rows "
        f"({n_pairs} pairs × ~{len(result) // max(n_pairs, 1)} concepts; "
        f"{same_lang_count} same-language rows)"
    )


CONFIGS = {
    "concept_verse_edge":          lambda: import_trajectory_config("concept_verse_edge"),
    "concept_trajectory":          lambda: import_trajectory_config("concept_trajectory"),
    "concept_verse_edge_sp":       lambda: import_trajectory_config("concept_verse_edge_sp"),
    "concept_trajectory_sp":       lambda: import_trajectory_config("concept_trajectory_sp"),
    "concept_verse_edge_bt":       build_concept_verse_edge_bt,
    "concept_trajectory_bt":       build_concept_trajectory_bt,
    "concept_verse_edge_pseu":     build_concept_verse_edge_pseu,
    "concept_trajectory_pseu":     build_concept_trajectory_pseu,
    "concept_drift":               build_concept_drift,
    "concept_drift_itp":           build_concept_drift_pseu,
    "concept_drift_hamilton":      build_concept_drift_hamilton,
    "community_candidate":         lambda: import_community_config("community_candidate"),
    "community_membership":        lambda: import_community_config("community_membership"),
    "concept_centroids":           build_concept_centroids,
    "concept_aliases":             build_concept_aliases,
    "concept_verse_edge_patr":     build_concept_verse_edge_patr,
    "concept_verse_edge_philo":    build_concept_verse_edge_philo,
    "concept_verse_edge_josephus": build_concept_verse_edge_josephus,
    "concept_verse_edge_targum":   build_concept_verse_edge_targum,
    "concept_verse_edge_talmud":   build_concept_verse_edge_talmud,
    "concept_verse_edge_nhc":      build_concept_verse_edge_nhc,
    "concept_trajectory_series":   build_concept_trajectory_series,
    "concept_drift_sequential":    build_concept_drift_sequential,
}


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", help="Build only this config")
    args = parser.parse_args()

    configs = {args.config: CONFIGS[args.config]} if args.config else CONFIGS
    if args.config and args.config not in CONFIGS:
        print(f"Unknown config '{args.config}'. Valid: {list(CONFIGS)}")
        raise SystemExit(1)

    print(f"Building {len(configs)} concept-analysis config(s) ...")
    for name, fn in configs.items():
        fn()

    print(f"\nDone. Output in {OUT}")


if __name__ == "__main__":
    main()