Add complete dataset: all sources, metadata, scripts, docs, and phylo enrichment

Syncs HuggingFace repo with full GitHub dataset:
- 1,177 lexicons (modern + ancient languages)
- 1,110 language profiles
- 102 audit trails
- 53 validation sets
- cognate_pipeline package (full Python source)
- All scripts (ingest, build, validate, scrape)
- All docs (PRDs, adversarial audits, database reference)
- Phylogenetic enrichment: phylo_pairs.tsv (386K pairs), Glottolog CLDF tree
- Additional data: gothic, iberian, ugaritic, religious_terms, linear_a, cited_sources

.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.pyc
+.DS_Store
+Thumbs.db
+
+# Cloned CLDF source repositories (large, not ours to commit)
+sources/
+
+# Training data (too large for git, regenerated from scripts)
+data/training/lexicons/
+data/training/cognate_pairs/
+# data/training/validation/ — now tracked via Git LFS

LICENSE

@@ -0,0 +1,27 @@
+Creative Commons Attribution-ShareAlike 4.0 International
+
+Copyright (c) 2026 Nacryos
+
+This work is licensed under the Creative Commons Attribution-ShareAlike 4.0
+International License. To view a copy of this license, visit
+http://creativecommons.org/licenses/by-sa/4.0/ or send a letter to
+Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
+
+You are free to:
+
+  Share - copy and redistribute the material in any medium or format
+  Adapt - remix, transform, and build upon the material for any purpose,
+          even commercially
+
+Under the following terms:
+
+  Attribution - You must give appropriate credit, provide a link to the
+                license, and indicate if changes were made.
+  ShareAlike  - If you remix, transform, or build upon the material, you
+                must distribute your contributions under the same license.
+
+No additional restrictions - You may not apply legal terms or technological
+measures that legally restrict others from doing anything the license permits.
+
+Note: Individual data sources used in this dataset may have their own licenses.
+See docs/DATABASE_REFERENCE.md Section 5 (Source Registry) for details.

README.md

@@ -0,0 +1,158 @@
+# Ancient Scripts Decipherment Datasets
+
+Collated datasets for the paper:
+
+> **Deciphering Undersegmented Ancient Scripts Using Phonetic Prior**
+> Jiaming Luo, Frederik Hartmann, Enrico Santus, Regina Barzilay, Yuan Cao
+> *Transactions of the Association for Computational Linguistics*, 2021
+> [arXiv:2010.11054](https://arxiv.org/abs/2010.11054)
+
+This repository gathers the training datasets used in the paper — both those hosted in the authors' GitHub repos and the external cited sources.
+
+---
+
+## Repository Structure
+
+```
+data/
+├── gothic/                          # Gothic language data
+│   ├── got.pretrained.pth           # Pretrained phonological embeddings (PyTorch)
+│   ├── segments.pkl                 # Phonetic segment data (Python pickle)
+│   ├── gotica.txt                   # Gothic Bible plain text (Wulfila project)
+│   └── gotica.xml.zip               # Gothic Bible TEI XML (Wulfila project)
+│
+├── ugaritic/                        # Ugaritic-Hebrew cognate data
+│   ├── uga-heb.no_spe.cog          # Full cognate pairs (TSV, ~7,353 tokens)
+│   └── uga-heb.small.no_spe.cog    # Small training subset (~10% of full)
+│
+├── iberian/                         # Iberian inscription data
+│   └── iberian.csv                  # Cleaned Hesperia epigraphy (3,466 chunks)
+│
+├── religious_terms/                 # ** CURATED SUBSET: Religious vocabulary **
+│   ├── README.md                    # Methodology and category definitions
+│   ├── ugaritic_hebrew_religious.tsv  # ~170 Ug-Heb cognate pairs (deity, ritual, sacred)
+│   ├── gothic_religious.tsv         # ~65 Gothic Bible religious terms
+│   └── iberian_religious.tsv        # ~40 Iberian votive/religious elements
+│
+├── validation/                      # Phylogenetic validation dataset (9 branches)
+│   ├── README.md                    # Format, sources, concept list
+│   ├── concepts.tsv                 # 40 shared concept IDs
+│   ├── germanic.tsv                 # got, ang, non, goh (~160 entries)
+│   ├── celtic.tsv                   # sga, cym, bre (~120 entries)
+│   ├── balto_slavic.tsv             # lit, chu, rus (~120 entries)
+│   ├── indo_iranian.tsv             # san, ave, fas (~120 entries)
+│   ├── italic.tsv                   # lat, osc, xum (~120 entries)
+│   ├── hellenic.tsv                 # grc, gmy (~80 entries)
+│   ├── semitic.tsv                  # heb, arb, amh (~120 entries)
+│   ├── turkic.tsv                   # otk, tur, aze (~120 entries)
+│   └── uralic.tsv                   # fin, hun, est (~120 entries)
+│
+└── cited_sources/                   # External datasets cited in the paper
+    ├── genesis/
+    │   ├── Hebrew.xml               # Hebrew Bible (Christodouloupoulos & Steedman 2015)
+    │   └── Latin.xml                # Latin Bible (same corpus)
+    ├── basque/
+    │   ├── Basque-NT.xml            # Basque New Testament (same corpus)
+    │   └── Trask_Etymological_Dictionary_Basque.pdf  # Trask's Basque etymological dictionary
+    └── iberian_names/
+        └── RodriguezRamos2014.pdf   # Iberian onomastic index (personal names)
+```
+
+---
+
+## Dataset Details
+
+### Gothic (`data/gothic/`)
+
+| File | Source | Description |
+|---|---|---|
+| `got.pretrained.pth` | [DecipherUnsegmented](https://github.com/j-luo93/DecipherUnsegmented) | Pretrained phonological embeddings trained on Gothic IPA data |
+| `segments.pkl` | [DecipherUnsegmented](https://github.com/j-luo93/DecipherUnsegmented) | Serialized phonetic segment inventory |
+| `gotica.txt` | [Wulfila Project](https://www.wulfila.be/gothic/download/) | Plain text of the Gothic Bible (4th century CE translation by Bishop Wulfila) |
+| `gotica.xml.zip` | [Wulfila Project](https://www.wulfila.be/gothic/download/) | TEI P5 XML encoding with linguistic annotations |
+
+The Gothic Bible is the primary source of Gothic text. The paper uses unsegmented Gothic inscriptions from the 3rd-10th century AD period.
+
+### Ugaritic (`data/ugaritic/`)
+
+| File | Source | Description |
+|---|---|---|
+| `uga-heb.no_spe.cog` | [NeuroDecipher](https://github.com/j-luo93/NeuroDecipher) | Full Ugaritic-Hebrew cognate pairs |
+| `uga-heb.small.no_spe.cog` | [NeuroDecipher](https://github.com/j-luo93/NeuroDecipher) | ~10% training subset |
+
+**Format:** Tab-separated values. Each row is a cognate pair. Column 1 = Ugaritic transliteration, Column 2 = Hebrew transliteration. `|` separates multiple cognates; `_` marks missing entries. Originally from Snyder et al. (2010), covering 7,353 segmented tokens from the 14th-12th century BC.
+
+### Iberian (`data/iberian/`)
+
+| File | Source | Description |
+|---|---|---|
+| `iberian.csv` | [DecipherUnsegmented](https://github.com/j-luo93/DecipherUnsegmented) | Cleaned epigraphic inscriptions |
+
+**Format:** CSV with columns `REF. HESPERIA` (inscription reference code) and `cleaned` (transcribed text). Contains 3,466 undersegmented character chunks from the 6th-1st century BC. Sourced from the [Hesperia database](http://hesperia.ucm.es/en/proyecto_hesperia.php) and cleaned via the authors' Jupyter notebook.
+
+### Cited Sources (`data/cited_sources/`)
+
+These are external datasets referenced in the paper for known-language vocabularies and comparison:
+
+| File | Citation | Usage in Paper |
+|---|---|---|
+| `genesis/Hebrew.xml` | Christodouloupoulos & Steedman (2015) | Hebrew vocabulary for Ugaritic comparison |
+| `genesis/Latin.xml` | Christodouloupoulos & Steedman (2015) | Latin vocabulary for cross-linguistic comparison |
+| `basque/Basque-NT.xml` | Christodouloupoulos & Steedman (2015) | Basque vocabulary for Iberian comparison |
+| `basque/Trask_Etymological_Dictionary_Basque.pdf` | Trask (2008) | Basque etymological data |
+| `iberian_names/RodriguezRamos2014.pdf` | Rodriguez Ramos (2014) | Iberian personal name lists with Latin correspondences |
+
+The Bible texts are from the [Massively Parallel Bible Corpus](https://github.com/christos-c/bible-corpus) (CC0 licensed).
+
+---
+
+## Additional Data Sources (Not Included)
+
+The following sources were cited in the paper but are not machine-readable or freely downloadable:
+
+- **Wiktionary descendant trees** for Proto-Germanic, Old Norse, and Old English vocabularies — extracted by the authors from Wiktionary's structured data
+- **Original Hesperia epigraphy** (`hesperia_epigraphy.csv`) — referenced in the DecipherUnsegmented README but not present in the repository
+
+---
+
+## Cognate Detection Pipeline
+
+The `cognate_pipeline/` directory contains a full Python package for cross-linguistic cognate detection, built on the datasets in this repository. It provides:
+
+- **Ingestion** of CSV/TSV/COG, CLDF, Wiktionary JSONL, and generic JSON sources
+- **Phonetic normalisation** with transcription type tracking (IPA, transliteration, orthographic)
+- **SCA sound class encoding** (List 2012) for phonological comparison
+- **Family-aware cognate candidate generation** (tags `cognate_inherited` vs `similarity_only`)
+- **Weighted Levenshtein scoring** with SCA-class-aware substitution costs
+- **Clustering** via connected components or UPGMA
+- **PostgreSQL/PostGIS database** with 8 normalised tables and Alembic migrations
+- **Export** to CLDF Wordlist and JSON-LD formats
+- **Full provenance tracking** through every pipeline stage
+
+Supports 36 languages across 9 phylogenetic branches (Germanic, Celtic, Balto-Slavic, Indo-Iranian, Italic, Hellenic, Semitic, Turkic, Uralic) plus isolates, with Glottocode resolution and IPA transcriptions.
+
+See `data/validation/README.md` for the phylogenetic validation dataset.
+
+See [`cognate_pipeline/README.md`](cognate_pipeline/README.md) for installation and usage.
+
+---
+
+## Original Repositories
+
+- [j-luo93/DecipherUnsegmented](https://github.com/j-luo93/DecipherUnsegmented) — main code for the paper
+- [j-luo93/NeuroDecipher](https://github.com/j-luo93/NeuroDecipher) — predecessor (Ugaritic/Linear B decipherment)
+- [j-luo93/xib](https://github.com/j-luo93/xib) — earlier Iberian codebase
+
+## Paper Citation
+
+```bibtex
+@article{luo2021deciphering,
+  title={Deciphering Undersegmented Ancient Scripts Using Phonetic Prior},
+  author={Luo, Jiaming and Hartmann, Frederik and Santus, Enrico and Barzilay, Regina and Cao, Yuan},
+  journal={Transactions of the Association for Computational Linguistics},
+  volume={9},
+  pages={69--81},
+  year={2021},
+  doi={10.1162/tacl_a_00354}
+}
+```

audit_sources.py

@@ -0,0 +1,237 @@
+"""
+Exhaustive audit of Source values across ALL 1,135 lexicon TSV files.
+Checks EVERY ROW in EVERY FILE.
+"""
+import csv
+import os
+import sys
+from collections import defaultdict, Counter
+
+LEXICON_DIR = r"C:\Users\alvin\hf-ancient-scripts\data\training\lexicons"
+
+VALID_SOURCES = {
+    "abvd", "wikipron", "northeuralex", "wold", "wiktionary", "wiktionary_cat",
+    "sinotibetan", "palaeolexicon", "ediana", "oracc_ecut", "tir_raetica",
+    "kaikki", "kassian2010", "kassian2010_basic", "seed", "wikipedia", "avesta_org"
+}
+
+# Counters
+total_entries = 0
+valid_source_count = 0
+empty_source_count = 0
+dash_source_count = 0
+unknown_source_count = 0
+whitespace_only_count = 0
+
+# Track all unique source values
+all_sources = Counter()
+
+# Track unknown source values and where they appear
+unknown_sources = defaultdict(list)  # source_val -> [(file, row_num, word)]
+
+# Track files with problems
+files_with_empty = defaultdict(list)    # file -> [(row_num, word, ipa)]
+files_with_dash = defaultdict(list)     # file -> [(row_num, word, ipa)]
+files_with_unknown = defaultdict(list)  # file -> [(row_num, word, source_val)]
+
+# Per-file stats
+file_stats = {}  # file -> {total, valid, empty, dash, unknown}
+
+# Files with no Source column at all
+files_missing_source_col = []
+
+tsv_files = sorted([f for f in os.listdir(LEXICON_DIR) if f.endswith(".tsv")])
+print(f"Found {len(tsv_files)} TSV files to audit.\n")
+
+for fname in tsv_files:
+    fpath = os.path.join(LEXICON_DIR, fname)
+    f_total = 0
+    f_valid = 0
+    f_empty = 0
+    f_dash = 0
+    f_unknown = 0
+    f_whitespace = 0
+
+    with open(fpath, "r", encoding="utf-8") as f:
+        reader = csv.DictReader(f, delimiter="\t")
+
+        # Check if Source column exists
+        if reader.fieldnames is None or "Source" not in reader.fieldnames:
+            files_missing_source_col.append(fname)
+            # Still count rows
+            for row in reader:
+                total_entries += 1
+                f_total += 1
+                empty_source_count += 1
+                f_empty += 1
+            file_stats[fname] = {"total": f_total, "valid": 0, "empty": f_total, "dash": 0, "unknown": 0, "whitespace": 0}
+            continue
+
+        for row_num, row in enumerate(reader, start=2):  # row 1 is header
+            total_entries += 1
+            f_total += 1
+
+            source = row.get("Source", "")
+            word = row.get("Word", "???")
+            ipa = row.get("IPA", "???")
+
+            if source is None:
+                source = ""
+
+            raw_source = source
+            source_stripped = source.strip()
+
+            # Track all source values
+            all_sources[raw_source] += 1
+
+            if source_stripped == "":
+                empty_source_count += 1
+                f_empty += 1
+                files_with_empty[fname].append((row_num, word, ipa))
+            elif source_stripped == "-":
+                dash_source_count += 1
+                f_dash += 1
+                files_with_dash[fname].append((row_num, word, ipa))
+            elif source_stripped != raw_source:
+                # Has leading/trailing whitespace but non-empty
+                whitespace_only_count += 1
+                f_whitespace += 1
+                if source_stripped in VALID_SOURCES:
+                    valid_source_count += 1
+                    f_valid += 1
+                else:
+                    unknown_source_count += 1
+                    f_unknown += 1
+                    unknown_sources[raw_source].append((fname, row_num, word))
+                    files_with_unknown[fname].append((row_num, word, raw_source))
+            elif source_stripped in VALID_SOURCES:
+                valid_source_count += 1
+                f_valid += 1
+            else:
+                unknown_source_count += 1
+                f_unknown += 1
+                unknown_sources[source_stripped].append((fname, row_num, word))
+                files_with_unknown[fname].append((row_num, word, source_stripped))
+
+    file_stats[fname] = {
+        "total": f_total, "valid": f_valid, "empty": f_empty,
+        "dash": f_dash, "unknown": f_unknown, "whitespace": f_whitespace
+    }
+
+# ============================================================
+# REPORT
+# ============================================================
+print("=" * 80)
+print("EXHAUSTIVE SOURCE AUDIT REPORT")
+print("=" * 80)
+
+print(f"\nFiles scanned:           {len(tsv_files)}")
+print(f"Total entries (rows):    {total_entries:,}")
+print(f"  Valid source:          {valid_source_count:,}  ({100*valid_source_count/total_entries:.2f}%)")
+print(f"  Empty/missing source:  {empty_source_count:,}  ({100*empty_source_count/total_entries:.4f}%)")
+print(f"  Dash '-' as source:    {dash_source_count:,}  ({100*dash_source_count/total_entries:.4f}%)")
+print(f"  Unknown source value:  {unknown_source_count:,}  ({100*unknown_source_count/total_entries:.4f}%)")
+print(f"  (Whitespace-padded):   {whitespace_only_count:,}")
+
+# Missing Source column
+if files_missing_source_col:
+    print(f"\n{'='*80}")
+    print(f"FILES MISSING 'Source' COLUMN ENTIRELY: {len(files_missing_source_col)}")
+    print("="*80)
+    for f in files_missing_source_col:
+        print(f"  - {f}")
+
+# All unique source values
+print(f"\n{'='*80}")
+print(f"ALL UNIQUE SOURCE VALUES (across entire database):")
+print("="*80)
+for src, count in sorted(all_sources.items(), key=lambda x: -x[1]):
+    marker = ""
+    s = src.strip()
+    if s == "":
+        marker = "  <-- EMPTY"
+    elif s == "-":
+        marker = "  <-- DASH"
+    elif s not in VALID_SOURCES:
+        marker = "  <-- UNKNOWN"
+    print(f"  '{src}' : {count:,} entries{marker}")
+
+# Unknown source values detail
+if unknown_sources:
+    print(f"\n{'='*80}")
+    print(f"UNKNOWN SOURCE VALUES (not in valid list):")
+    print("="*80)
+    for src_val, occurrences in sorted(unknown_sources.items(), key=lambda x: -len(x[1])):
+        print(f"\n  Source value: '{src_val}' ({len(occurrences)} occurrences)")
+        for fname, row_num, word in occurrences[:10]:
+            print(f"    - {fname} row {row_num}: word='{word}'")
+        if len(occurrences) > 10:
+            print(f"    ... and {len(occurrences)-10} more")
+
+# Files with empty sources
+if files_with_empty:
+    print(f"\n{'='*80}")
+    print(f"FILES WITH EMPTY SOURCE ENTRIES:")
+    print("="*80)
+    for fname, entries in sorted(files_with_empty.items()):
+        stats = file_stats[fname]
+        pct = 100 * len(entries) / stats["total"] if stats["total"] > 0 else 0
+        print(f"\n  {fname}: {len(entries)} empty / {stats['total']} total ({pct:.1f}%)")
+        if pct > 1.0:
+            print(f"    ** >1% empty — listing all entries:")
+            for row_num, word, ipa in entries:
+                print(f"      Row {row_num}: Word='{word}', IPA='{ipa}'")
+        else:
+            for row_num, word, ipa in entries[:5]:
+                print(f"      Row {row_num}: Word='{word}', IPA='{ipa}'")
+            if len(entries) > 5:
+                print(f"      ... and {len(entries)-5} more")
+
+# Files with dash sources
+if files_with_dash:
+    print(f"\n{'='*80}")
+    print(f"FILES WITH DASH '-' AS SOURCE ({len(files_with_dash)} files):")
+    print("="*80)
+    for fname, entries in sorted(files_with_dash.items()):
+        stats = file_stats[fname]
+        pct = 100 * len(entries) / stats["total"] if stats["total"] > 0 else 0
+        print(f"  {fname}: {len(entries)} dash / {stats['total']} total ({pct:.1f}%)")
+        if len(entries) <= 5:
+            for row_num, word, ipa in entries:
+                print(f"      Row {row_num}: Word='{word}', IPA='{ipa}'")
+
+# Files with unknown sources
+if files_with_unknown:
+    print(f"\n{'='*80}")
+    print(f"FILES WITH UNKNOWN SOURCE VALUES ({len(files_with_unknown)} files):")
+    print("="*80)
+    for fname, entries in sorted(files_with_unknown.items()):
+        stats = file_stats[fname]
+        print(f"\n  {fname}: {len(entries)} unknown / {stats['total']} total")
+        for row_num, word, src_val in entries[:10]:
+            print(f"      Row {row_num}: Word='{word}', Source='{src_val}'")
+        if len(entries) > 10:
+            print(f"      ... and {len(entries)-10} more")
+
+# Summary of problematic files
+problem_files = set()
+problem_files.update(files_with_empty.keys())
+problem_files.update(files_with_dash.keys())
+problem_files.update(files_with_unknown.keys())
+problem_files.update(files_missing_source_col)
+
+print(f"\n{'='*80}")
+print(f"SUMMARY")
+print("="*80)
+print(f"Total files:                 {len(tsv_files)}")
+print(f"Files with problems:         {len(problem_files)}")
+print(f"  - Missing Source column:   {len(files_missing_source_col)}")
+print(f"  - With empty sources:      {len(files_with_empty)}")
+print(f"  - With dash sources:       {len(files_with_dash)}")
+print(f"  - With unknown sources:    {len(files_with_unknown)}")
+print(f"Clean files:                 {len(tsv_files) - len(problem_files)}")
+
+if not problem_files:
+    print("\n*** ALL FILES PASS: Every row in every file has a valid source. ***")
+else:
+    print(f"\n*** {len(problem_files)} FILES HAVE ISSUES — see details above. ***")

char_analysis.txt

@@ -0,0 +1,81 @@
+Total words: 266
+Characters covered by map keys: ['a', 'b', 'd', 'e', 'g', 'h', 'i', 'k', 'l', 'm', 'n', 'p', 'r', 's', 't', 'u', 'w', 'y', 'z']
+
+All unique characters in Word column (37):
+  ' '        U+0020  char_occurrences=   2  UNMAPPED
+  '.'        U+002E  char_occurrences=   2  UNMAPPED
+  '6'        U+0036  char_occurrences=   1  UNMAPPED
+  'a'        U+0061  char_occurrences= 343  MAPPED
+  'b'        U+0062  char_occurrences=   3  MAPPED
+  'd'        U+0064  char_occurrences=  22  MAPPED
+  'e'        U+0065  char_occurrences=  67  MAPPED
+  'g'        U+0067  char_occurrences=  17  MAPPED
+  'h'        U+0068  char_occurrences=  22  MAPPED
+  'i'        U+0069  char_occurrences= 167  MAPPED
+  'j'        U+006A  char_occurrences=   2  UNMAPPED
+  'k'        U+006B  char_occurrences=  71  MAPPED
+  'l'        U+006C  char_occurrences=  52  MAPPED
+  'm'        U+006D  char_occurrences=  37  MAPPED
+  'n'        U+006E  char_occurrences=  95  MAPPED
+  'p'        U+0070  char_occurrences=  58  MAPPED
+  'r'        U+0072  char_occurrences=  85  MAPPED
+  's'        U+0073  char_occurrences=  82  MAPPED
+  't'        U+0074  char_occurrences=  61  MAPPED
+  'u'        U+0075  char_occurrences= 141  MAPPED
+  'w'        U+0077  char_occurrences=  43  MAPPED
+  'x'        U+0078  char_occurrences=   1  UNMAPPED
+  'y'        U+0079  char_occurrences=  16  MAPPED
+  'z'        U+007A  char_occurrences=  89  MAPPED
+  'à'        U+00E0  char_occurrences=   1  UNMAPPED
+  'í'        U+00ED  char_occurrences=   1  UNMAPPED
+  'ú'        U+00FA  char_occurrences=   1  UNMAPPED
+  'ā'        U+0101  char_occurrences=  22  UNMAPPED
+  'ē'        U+0113  char_occurrences=   8  UNMAPPED
+  'ī'        U+012B  char_occurrences=   4  UNMAPPED
+  'š'        U+0161  char_occurrences=  97  UNMAPPED
+  'ū'        U+016B  char_occurrences=   3  UNMAPPED
+  '́'        U+0301  char_occurrences=   2  UNMAPPED
+  '̩'        U+0329  char_occurrences=   1  UNMAPPED
+  '͡'        U+0361  char_occurrences=   1  UNMAPPED
+  'ḫ'        U+1E2B  char_occurrences=  46  UNMAPPED
+  'ṣ'        U+1E63  char_occurrences=   1  UNMAPPED
+
+=== UNMAPPED CHARACTERS (entries affected) ===
+  'š'        U+0161  entries=  77  char_occurrences=  97
+  'ḫ'        U+1E2B  entries=  37  char_occurrences=  46
+  'ā'        U+0101  entries=  22  char_occurrences=  22
+  'ē'        U+0113  entries=   8  char_occurrences=   8
+  'ī'        U+012B  entries=   4  char_occurrences=   4
+  'ū'        U+016B  entries=   3  char_occurrences=   3
+  'j'        U+006A  entries=   2  char_occurrences=   2
+  '́'        U+0301  entries=   2  char_occurrences=   2
+  '.'        U+002E  entries=   2  char_occurrences=   2
+  'à'        U+00E0  entries=   1  char_occurrences=   1
+  'ú'        U+00FA  entries=   1  char_occurrences=   1
+  '6'        U+0036  entries=   1  char_occurrences=   1
+  '͡'        U+0361  entries=   1  char_occurrences=   1
+  ' '        U+0020  entries=   1  char_occurrences=   2
+  '̩'        U+0329  entries=   1  char_occurrences=   1
+  'í'        U+00ED  entries=   1  char_occurrences=   1
+  'x'        U+0078  entries=   1  char_occurrences=   1
+  'ṣ'        U+1E63  entries=   1  char_occurrences=   1
+
+=== EXAMPLE WORDS FOR EACH UNMAPPED CHARACTER ===
+  'š'        U+0161: ['addaaš', 'alpuš', 'ammiyaanteeššar', 'annaš', 'antuwaaḫḫaaš']
+  'ḫ'        U+1E2B: ['antuwaaḫḫaaš', 'arḫaš', 'eešḫaaḫru', 'eešḫar', 'eešḫarnuuzzi']
+  'ā'        U+0101: ['apiyā', 'arāwanzi', 'arāš', 'awārna', 'ašāwar']
+  'ē'        U+0113: ['alēl', 'nēpis', 'nēwas', 'nēšaš', 'pēr']
+  'ī'        U+012B: ['aurīš', 'lalatīna', 'tītan', 'īṣā́']
+  'ū'        U+016B: ['zūwaš', 'ūḫḫi', 'ḫūmanz']
+  'j'        U+006A: ['jā́nu', 'sjeus']
+  '́'        U+0301: ['jā́nu', 'īṣā́']
+  '.'        U+002E: ['munus.lugalaš', 'munus.lugalraaš']
+  'à'        U+00E0: ['šàer']
+  'ú'        U+00FA: ['úul']
+  '6'        U+0036: ['ku6']
+  '͡'        U+0361: ['marsant͡s']
+  ' '        U+0020: ['ninnudiš maš galgal']
+  '̩'        U+0329: ['iwr̩']
+  'í'        U+00ED: ['sígaš']
+  'x'        U+0078: ['xšap']
+  'ṣ'        U+1E63: ['īṣā́']

char_analysis2.txt

@@ -0,0 +1,70 @@
+
+=== 'š' (sh (s-caron)) U+0161 ===
+  Word=addaaš                          IPA=atːaːš
+  Word=alpuš                           IPA=alpuš
+  Word=ammiyaanteeššar                 IPA=ammijaːnteːššar
+  Word=annaš                           IPA=annaš
+  Word=antuwaaḫḫaaš                    IPA=antuwaːḫḫaːš
+  Word=araaaš                          IPA=araːaš
+  Word=arauwaaš                        IPA=arauwaːš
+  Word=ariyašeššar                     IPA=arijašeššar
+
+=== 'ḫ' (h-under (h with breve below)) U+1E2B ===
+  Word=antuwaaḫḫaaš                    IPA=antuwaːḫḫaːš
+  Word=arḫaš                           IPA=arxaš
+  Word=eešḫaaḫru                       IPA=eːšḫaːḫru
+  Word=eešḫar                          IPA=eːšḫar
+  Word=eešḫarnuuzzi                    IPA=eːšḫarnuːtsːi
+  Word=išḫaaššaraaš                    IPA=išḫaːššaraːš
+  Word=išḫimaaaš                       IPA=išḫimaːaš
+  Word=išḫāš                           IPA=išxaːš
+
+=== 'ā' (a-macron) U+0101 ===
+  Word=apiyā                           IPA=apijā
+  Word=arāwanzi                        IPA=arāwantsi
+  Word=arāš                            IPA=araːš
+  Word=awārna                          IPA=awaːrna
+  Word=ašāwar                          IPA=ašaːwar
+  Word=išḫāš                           IPA=išxaːš
+  Word=jā́nu                           IPA=jaː́nu
+  Word=paddāi                          IPA=patːāi
+
+=== 'ē' (e-macron) U+0113 ===
+  Word=alēl                            IPA=aleːl
+  Word=nēpis                           IPA=neːpis
+  Word=nēwas                           IPA=neːwas
+  Word=nēšaš                           IPA=neːšaš
+  Word=pēr                             IPA=peːr
+  Word=tēnawaš                         IPA=teːnawaš
+  Word=ēzzzzi                          IPA=ētsːtsːi
+  Word=ēšzi                            IPA=ēštsi
+
+=== 'ī' (i-macron) U+012B ===
+  Word=aurīš                           IPA=auriːš
+  Word=lalatīna                        IPA=lalatiːna
+  Word=tītan                           IPA=tiːtan
+  Word=īṣā́                            IPA=iːṣaː́
+
+=== 'ū' (u-macron) U+016B ===
+  Word=zūwaš                           IPA=tsūwaš
+  Word=ūḫḫi                            IPA=uːxːi
+  Word=ḫūmanz                          IPA=ḫūmants
+
+=== 'j' (j) U+006A ===
+  Word=jā́nu                           IPA=jaː́nu
+  Word=sjeus                           IPA=sjeus
+
+=== 'à' (a-grave) U+00E0 ===
+  Word=šàer                            IPA=šaer
+
+=== 'í' (i-acute) U+00ED ===
+  Word=sígaš                           IPA=síkaš
+
+=== 'ú' (u-acute) U+00FA ===
+  Word=úul                             IPA=úul
+
+=== 'ṣ' (s-dot-below) U+1E63 ===
+  Word=īṣā́                            IPA=iːṣaː́
+
+=== 'x' (x) U+0078 ===
+  Word=xšap                            IPA=xšap

cognate_pipeline/README.md

@@ -0,0 +1,3 @@
+# Cognate Pipeline
+
+Cross-linguistic cognate detection pipeline with provenance tracking.

cognate_pipeline/alembic.ini

@@ -0,0 +1,37 @@
+[alembic]
+script_location = src/cognate_pipeline/db/migrations
+prepend_sys_path = .
+sqlalchemy.url = postgresql+psycopg://postgres@localhost:5432/cognate_db
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

cognate_pipeline/config.example.yaml

@@ -0,0 +1,445 @@
+staging_dir: staging
+log_level: INFO
+batch_size: 5000
+
+# Glottolog languoid CSV (optional — needed for family-aware cognate detection)
+# glottolog_data_dir: /path/to/glottolog-data
+
+sources:
+  - name: ugaritic_hebrew
+    path: ../ancient-scripts-datasets/data/ugaritic/uga-heb.small.no_spe.cog
+    format: cog
+    license: "Research / Fair Use"
+    license_url: ""
+    citation_bibtex: |
+      @article{luo2021deciphering,
+        title={Deciphering Undersegmented Ancient Scripts Using Phonetic Prior},
+        author={Luo, Jiaming and Hartmann, Frederik and Santus, Enrico and Barzilay, Regina and Cao, Yuan},
+        journal={Transactions of the Association for Computational Linguistics},
+        year={2021}
+      }
+    column_mapping:
+      language: null
+      form: null
+      concept: null
+    delimiter: "\t"
+    extra:
+      lang_a: uga
+      lang_b: heb
+      header_a: "uga-no_spe"
+      header_b: "heb-no_spe"
+
+  - name: religious_terms
+    path: ../ancient-scripts-datasets/data/religious_terms/ugaritic_hebrew_religious.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: null
+      form: ugaritic_form
+      concept: english_meaning
+      ipa: null
+    delimiter: "\t"
+    extra:
+      lang_a_col: ugaritic_form
+      lang_b_col: hebrew_cognate
+
+  # --- Validation branches (9 phylogenetic families) ---
+
+  - name: germanic
+    path: ../ancient-scripts-datasets/data/validation/germanic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: celtic
+    path: ../ancient-scripts-datasets/data/validation/celtic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: balto_slavic
+    path: ../ancient-scripts-datasets/data/validation/balto_slavic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: indo_iranian
+    path: ../ancient-scripts-datasets/data/validation/indo_iranian.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: italic
+    path: ../ancient-scripts-datasets/data/validation/italic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: hellenic
+    path: ../ancient-scripts-datasets/data/validation/hellenic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: semitic
+    path: ../ancient-scripts-datasets/data/validation/semitic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: turkic
+    path: ../ancient-scripts-datasets/data/validation/turkic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: uralic
+    path: ../ancient-scripts-datasets/data/validation/uralic.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  # --- Cross-family names subset (deity, proper, place names) ---
+
+  - name: names
+    path: ../ancient-scripts-datasets/data/validation/names.tsv
+    format: tsv
+    license: "Research / Fair Use"
+    column_mapping:
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  # --- Expanded validation branches (original langs + CLDF additions) ---
+
+  - name: germanic_expanded
+    path: ../ancient-scripts-datasets/data/validation/germanic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: &expanded_cols
+      language: Language_ID
+      form: Form
+      concept: Parameter_ID
+      ipa: IPA
+      glottocode: Glottocode
+
+  - name: celtic_expanded
+    path: ../ancient-scripts-datasets/data/validation/celtic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: balto_slavic_expanded
+    path: ../ancient-scripts-datasets/data/validation/balto_slavic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: indo_iranian_expanded
+    path: ../ancient-scripts-datasets/data/validation/indo_iranian_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: italic_expanded
+    path: ../ancient-scripts-datasets/data/validation/italic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: hellenic_expanded
+    path: ../ancient-scripts-datasets/data/validation/hellenic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: semitic_expanded
+    path: ../ancient-scripts-datasets/data/validation/semitic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: turkic_expanded
+    path: ../ancient-scripts-datasets/data/validation/turkic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: uralic_expanded
+    path: ../ancient-scripts-datasets/data/validation/uralic_expanded.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  # --- New language families ---
+
+  - name: albanian
+    path: ../ancient-scripts-datasets/data/validation/albanian.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: armenian
+    path: ../ancient-scripts-datasets/data/validation/armenian.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: dravidian
+    path: ../ancient-scripts-datasets/data/validation/dravidian.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: kartvelian
+    path: ../ancient-scripts-datasets/data/validation/kartvelian.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: austronesian
+    path: ../ancient-scripts-datasets/data/validation/austronesian.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: sino_tibetan
+    path: ../ancient-scripts-datasets/data/validation/sino_tibetan.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: mongolic
+    path: ../ancient-scripts-datasets/data/validation/mongolic.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: tungusic
+    path: ../ancient-scripts-datasets/data/validation/tungusic.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: japonic
+    path: ../ancient-scripts-datasets/data/validation/japonic.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: koreanic
+    path: ../ancient-scripts-datasets/data/validation/koreanic.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: northeast_caucasian
+    path: ../ancient-scripts-datasets/data/validation/northeast_caucasian.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: northwest_caucasian
+    path: ../ancient-scripts-datasets/data/validation/northwest_caucasian.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: eskimo_aleut
+    path: ../ancient-scripts-datasets/data/validation/eskimo_aleut.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: isolates
+    path: ../ancient-scripts-datasets/data/validation/isolates.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: afroasiatic_berber
+    path: ../ancient-scripts-datasets/data/validation/afroasiatic_berber.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: afroasiatic_chadic
+    path: ../ancient-scripts-datasets/data/validation/afroasiatic_chadic.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: afroasiatic_cushitic
+    path: ../ancient-scripts-datasets/data/validation/afroasiatic_cushitic.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: niger_congo_bantu
+    path: ../ancient-scripts-datasets/data/validation/niger_congo_bantu.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: tai_kadai
+    path: ../ancient-scripts-datasets/data/validation/tai_kadai.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: austroasiatic
+    path: ../ancient-scripts-datasets/data/validation/austroasiatic.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: mayan
+    path: ../ancient-scripts-datasets/data/validation/mayan.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: uto_aztecan
+    path: ../ancient-scripts-datasets/data/validation/uto_aztecan.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: quechuan
+    path: ../ancient-scripts-datasets/data/validation/quechuan.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: hmong_mien
+    path: ../ancient-scripts-datasets/data/validation/hmong_mien.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: chukotko_kamchatkan
+    path: ../ancient-scripts-datasets/data/validation/chukotko_kamchatkan.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: yukaghir
+    path: ../ancient-scripts-datasets/data/validation/yukaghir.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: saharan
+    path: ../ancient-scripts-datasets/data/validation/saharan.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  - name: pama_nyungan
+    path: ../ancient-scripts-datasets/data/validation/pama_nyungan.tsv
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping: *expanded_cols
+
+  # --- Training data (full-dictionary scale) ---
+
+  - name: training_lexicons
+    path: ../ancient-scripts-datasets/data/training/lexicons/
+    format: tsv
+    license: "CC-BY / Research / WikiPron"
+    column_mapping:
+      language: null
+      form: Word
+      concept: Concept_ID
+      ipa: IPA
+    extra:
+      description: "Per-language lexicon TSVs from WikiPron + CLDF sources"
+      entries_target: 4000000
+
+  - name: training_cognate_pairs
+    path: ../ancient-scripts-datasets/data/training/cognate_pairs/
+    format: tsv
+    license: "CC-BY / Research"
+    column_mapping:
+      language: null
+      form: null
+      concept: Concept_ID
+    extra:
+      description: "Cognate pair files (inherited, similarity, borrowing)"
+
+database:
+  host: localhost
+  port: 5432
+  name: cognate_db
+  user: postgres
+  password: ""
+  schema_name: public
+
+normalisation:
+  unicode_form: NFC
+  strip_suprasegmentals: false
+  strip_whitespace: true
+  ipa_backend_priority:
+    - attested
+    - epitran
+    - phonemizer
+  transliteration_passthrough: true
+
+cognate:
+  method: baseline_lev
+  clustering: connected_components
+  threshold: 0.5
+  family_aware: true
+  batch_size: 10000
+
+export:
+  cldf_output_dir: export/cldf
+  jsonld_output_dir: export/jsonld
+  include_provenance: true

cognate_pipeline/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cognate-pipeline"
+version = "0.1.0"
+description = "Cross-linguistic cognate detection pipeline with provenance tracking"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+dependencies = [
+    "typer>=0.12,<1",
+    "pydantic>=2.5,<3",
+    "pyyaml>=6,<7",
+    "orjson>=3.9,<4",
+    "sqlalchemy>=2.0,<3",
+    "geoalchemy2>=0.14,<1",
+    "psycopg[binary]>=3.1,<4",
+    "alembic>=1.13,<2",
+]
+
+[project.optional-dependencies]
+lingpy = ["lingpy>=2.6.12,<3"]
+epitran = ["epitran>=1.24,<2"]
+cldf = ["pycldf>=1.35,<2", "clldutils>=3.5,<4"]
+phonemizer = ["phonemizer>=3.2,<4"]
+all = [
+    "cognate-pipeline[lingpy,epitran,cldf,phonemizer]",
+]
+dev = [
+    "pytest>=8,<9",
+    "pytest-cov>=5,<6",
+]
+
+[project.scripts]
+cognate-pipeline = "cognate_pipeline.cli.main:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/cognate_pipeline"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "e2e: end-to-end tests requiring external services",
+]

cognate_pipeline/src/cognate_pipeline/__init__.py

@@ -0,0 +1,3 @@
+"""Cognate Pipeline — cross-linguistic cognate detection with provenance."""
+
+__version__ = "0.1.0"

cognate_pipeline/src/cognate_pipeline/cli/detect_cmd.py

@@ -0,0 +1,73 @@
+"""CLI handler for the detect-cognates subcommand."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import orjson
+
+from cognate_pipeline.config.loader import load_config
+from cognate_pipeline.config.schema import CognateMethod
+from cognate_pipeline.cognate.candidate_gen import generate_candidates
+from cognate_pipeline.cognate.baseline_levenshtein import BaselineLevenshtein
+from cognate_pipeline.cognate.lexstat_detector import LexStatDetector
+from cognate_pipeline.cognate.clustering import cluster_links
+from cognate_pipeline.normalise.models import NormalisedLexeme
+from cognate_pipeline.utils.logging_setup import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+def run_detect(config_path: str, method_override: str | None) -> None:
+    cfg = load_config(config_path)
+    setup_logging(cfg.log_level)
+
+    method = CognateMethod(method_override) if method_override else cfg.cognate.method
+
+    norm_dir = cfg.staging_dir / "normalised"
+    cog_dir = cfg.staging_dir / "cognate"
+    cog_dir.mkdir(parents=True, exist_ok=True)
+
+    # Load all normalised lexemes
+    lexemes: list[NormalisedLexeme] = []
+    for jsonl_path in sorted(norm_dir.glob("*.jsonl")):
+        if jsonl_path.name.startswith("_"):
+            continue
+        with jsonl_path.open("rb") as fh:
+            for line in fh:
+                lexemes.append(NormalisedLexeme.from_dict(orjson.loads(line)))
+    logger.info("Loaded %d normalised lexemes", len(lexemes))
+
+    # Generate candidate pairs
+    pairs = generate_candidates(lexemes, family_aware=cfg.cognate.family_aware)
+    logger.info("Generated %d candidate pairs", len(pairs))
+
+    # Score pairs
+    if method == CognateMethod.BASELINE_LEV:
+        scorer = BaselineLevenshtein()
+        links = scorer.score_pairs(pairs, threshold=cfg.cognate.threshold)
+    elif method == CognateMethod.LEXSTAT:
+        detector = LexStatDetector()
+        links = detector.detect(lexemes, threshold=cfg.cognate.threshold)
+    else:
+        raise ValueError(f"Unknown method: {method}")
+    logger.info("Scored %d cognate links above threshold", len(links))
+
+    # Cluster
+    sets = cluster_links(links, algorithm=cfg.cognate.clustering)
+    logger.info("Formed %d cognate sets", len(sets))
+
+    # Write links
+    links_path = cog_dir / "cognate_links.jsonl"
+    with links_path.open("wb") as fh:
+        for link in links:
+            fh.write(orjson.dumps(link.to_dict()) + b"\n")
+
+    # Write sets
+    sets_path = cog_dir / "cognate_sets.jsonl"
+    with sets_path.open("wb") as fh:
+        for cset in sets:
+            fh.write(orjson.dumps(cset.to_dict()) + b"\n")
+
+    logger.info("Cognate results written to %s", cog_dir)

cognate_pipeline/src/cognate_pipeline/cli/export_cldf_cmd.py

@@ -0,0 +1,24 @@
+"""CLI handler for the export-cldf subcommand."""
+
+from __future__ import annotations
+
+import logging
+
+from cognate_pipeline.config.loader import load_config
+from cognate_pipeline.db.connection import get_engine
+from cognate_pipeline.export.cldf_exporter import CldfExporter
+from cognate_pipeline.utils.logging_setup import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+def run_export_cldf(config_path: str) -> None:
+    cfg = load_config(config_path)
+    setup_logging(cfg.log_level)
+
+    engine = get_engine(cfg.database)
+    exporter = CldfExporter(engine, cfg.export)
+    out_dir = cfg.export.cldf_output_dir
+    out_dir.mkdir(parents=True, exist_ok=True)
+    exporter.export(out_dir)
+    logger.info("CLDF export written to %s", out_dir)

cognate_pipeline/src/cognate_pipeline/cli/export_jsonld_cmd.py

@@ -0,0 +1,24 @@
+"""CLI handler for the export-jsonld subcommand."""
+
+from __future__ import annotations
+
+import logging
+
+from cognate_pipeline.config.loader import load_config
+from cognate_pipeline.db.connection import get_engine
+from cognate_pipeline.export.jsonld_exporter import JsonLdExporter
+from cognate_pipeline.utils.logging_setup import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+def run_export_jsonld(config_path: str) -> None:
+    cfg = load_config(config_path)
+    setup_logging(cfg.log_level)
+
+    engine = get_engine(cfg.database)
+    exporter = JsonLdExporter(engine, cfg.export)
+    out_dir = cfg.export.jsonld_output_dir
+    out_dir.mkdir(parents=True, exist_ok=True)
+    exporter.export(out_dir)
+    logger.info("JSON-LD export written to %s", out_dir)

cognate_pipeline/src/cognate_pipeline/cli/ingest_cmd.py

@@ -0,0 +1,63 @@
+"""CLI handler for the ingest-sources subcommand."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import orjson
+
+from cognate_pipeline.config.loader import load_config
+from cognate_pipeline.config.schema import SourceFormat
+from cognate_pipeline.ingest.base import SourceIngester
+from cognate_pipeline.ingest.csv_ingester import CsvIngester
+from cognate_pipeline.ingest.cldf_ingester import CldfIngester
+from cognate_pipeline.ingest.json_ingester import JsonIngester
+from cognate_pipeline.ingest.wiktionary_ingester import WiktionaryIngester
+from cognate_pipeline.provenance.license_registry import LicenseRegistry
+from cognate_pipeline.utils.logging_setup import setup_logging
+
+logger = logging.getLogger(__name__)
+
+_FORMAT_TO_INGESTER: dict[SourceFormat, type[SourceIngester]] = {
+    SourceFormat.CLDF: CldfIngester,
+    SourceFormat.CSV: CsvIngester,
+    SourceFormat.TSV: CsvIngester,
+    SourceFormat.COG: CsvIngester,
+    SourceFormat.JSON: JsonIngester,
+    SourceFormat.NDJSON: JsonIngester,
+    SourceFormat.WIKTIONARY: WiktionaryIngester,
+}
+
+
+def run_ingest(config_path: str, output_dir: str | None) -> None:
+    cfg = load_config(config_path)
+    setup_logging(cfg.log_level)
+    registry = LicenseRegistry()
+
+    staging = Path(output_dir) if output_dir else cfg.staging_dir / "ingest"
+    staging.mkdir(parents=True, exist_ok=True)
+
+    for source_def in cfg.sources:
+        logger.info("Ingesting source: %s (%s)", source_def.name, source_def.format)
+        registry.register(
+            source_def.name, source_def.license, source_def.license_url,
+            source_def.citation_bibtex,
+        )
+        ingester_cls = _FORMAT_TO_INGESTER.get(source_def.format)
+        if ingester_cls is None:
+            logger.error("No ingester for format %s", source_def.format)
+            continue
+
+        ingester = ingester_cls(source_def)
+        out_path = staging / f"{source_def.name}.jsonl"
+        count = 0
+        with out_path.open("wb") as fh:
+            for lexeme in ingester.ingest():
+                fh.write(orjson.dumps(lexeme.to_dict()) + b"\n")
+                count += 1
+        logger.info("  Wrote %d lexemes to %s", count, out_path)
+
+    reg_path = staging / "_license_registry.json"
+    reg_path.write_bytes(orjson.dumps(registry.to_dict()))
+    logger.info("License registry saved to %s", reg_path)

cognate_pipeline/src/cognate_pipeline/cli/load_cmd.py

@@ -0,0 +1,63 @@
+"""CLI handler for the load-db subcommand."""
+
+from __future__ import annotations
+
+import logging
+
+import orjson
+
+from cognate_pipeline.config.loader import load_config
+from cognate_pipeline.db.connection import get_engine, get_session
+from cognate_pipeline.db.loader import BatchLoader
+from cognate_pipeline.utils.logging_setup import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+def run_load(config_path: str) -> None:
+    cfg = load_config(config_path)
+    setup_logging(cfg.log_level)
+
+    engine = get_engine(cfg.database)
+    loader = BatchLoader(engine, batch_size=cfg.batch_size)
+
+    # Load license registry
+    reg_path = cfg.staging_dir / "ingest" / "_license_registry.json"
+    if reg_path.exists():
+        registry = orjson.loads(reg_path.read_bytes())
+        loader.load_sources(registry)
+        logger.info("Loaded source metadata")
+
+    # Load normalised lexemes
+    norm_dir = cfg.staging_dir / "normalised"
+    for jsonl_path in sorted(norm_dir.glob("*.jsonl")):
+        if jsonl_path.name.startswith("_"):
+            continue
+        logger.info("Loading lexemes from %s", jsonl_path.name)
+        records = []
+        with jsonl_path.open("rb") as fh:
+            for line in fh:
+                records.append(orjson.loads(line))
+        loader.load_lexemes(records)
+
+    # Load cognate data
+    cog_dir = cfg.staging_dir / "cognate"
+    links_path = cog_dir / "cognate_links.jsonl"
+    if links_path.exists():
+        links = []
+        with links_path.open("rb") as fh:
+            for line in fh:
+                links.append(orjson.loads(line))
+        loader.load_cognate_links(links)
+        logger.info("Loaded %d cognate links", len(links))
+
+    sets_path = cog_dir / "cognate_sets.jsonl"
+    if sets_path.exists():
+        sets_data = []
+        with sets_path.open("rb") as fh:
+            for line in fh:
+                sets_data.append(orjson.loads(line))
+        loader.load_cognate_sets(sets_data)
+        logger.info("Loaded %d cognate sets", len(sets_data))
+
+    logger.info("Database load complete")

cognate_pipeline/src/cognate_pipeline/cli/main.py

@@ -0,0 +1,81 @@
+"""Main Typer application with 6 subcommands."""
+
+from __future__ import annotations
+
+import typer
+
+app = typer.Typer(
+    name="cognate-pipeline",
+    help="Cross-linguistic cognate detection pipeline with provenance tracking.",
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def ingest_sources(
+    config: str = typer.Option(..., "--config", "-c", help="Path to config YAML"),
+    output_dir: str = typer.Option(
+        None, "--output-dir", "-o", help="Override staging output directory"
+    ),
+) -> None:
+    """Ingest lexical sources into staging JSONL files."""
+    from .ingest_cmd import run_ingest
+
+    run_ingest(config, output_dir)
+
+
+@app.command()
+def normalise_ipa(
+    config: str = typer.Option(..., "--config", "-c", help="Path to config YAML"),
+) -> None:
+    """Normalise IPA and compute sound classes for staged lexemes."""
+    from .normalise_cmd import run_normalise
+
+    run_normalise(config)
+
+
+@app.command()
+def detect_cognates(
+    config: str = typer.Option(..., "--config", "-c", help="Path to config YAML"),
+    method: str = typer.Option(
+        None, "--method", "-m", help="Override cognate detection method"
+    ),
+) -> None:
+    """Detect cognate candidates and cluster into cognate sets."""
+    from .detect_cmd import run_detect
+
+    run_detect(config, method)
+
+
+@app.command()
+def load_db(
+    config: str = typer.Option(..., "--config", "-c", help="Path to config YAML"),
+) -> None:
+    """Load staged data into PostgreSQL."""
+    from .load_cmd import run_load
+
+    run_load(config)
+
+
+@app.command()
+def export_cldf(
+    config: str = typer.Option(..., "--config", "-c", help="Path to config YAML"),
+) -> None:
+    """Export database contents as CLDF Wordlist."""
+    from .export_cldf_cmd import run_export_cldf
+
+    run_export_cldf(config)
+
+
+@app.command()
+def export_jsonld(
+    config: str = typer.Option(..., "--config", "-c", help="Path to config YAML"),
+) -> None:
+    """Export cognate links as JSON-LD."""
+    from .export_jsonld_cmd import run_export_jsonld
+
+    run_export_jsonld(config)
+
+
+if __name__ == "__main__":
+    app()

cognate_pipeline/src/cognate_pipeline/cli/normalise_cmd.py

@@ -0,0 +1,40 @@
+"""CLI handler for the normalise-ipa subcommand."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+import orjson
+
+from cognate_pipeline.config.loader import load_config
+from cognate_pipeline.ingest.models import RawLexeme
+from cognate_pipeline.normalise.ipa_normaliser import IpaNormaliser
+from cognate_pipeline.utils.logging_setup import setup_logging
+
+logger = logging.getLogger(__name__)
+
+
+def run_normalise(config_path: str) -> None:
+    cfg = load_config(config_path)
+    setup_logging(cfg.log_level)
+
+    ingest_dir = cfg.staging_dir / "ingest"
+    norm_dir = cfg.staging_dir / "normalised"
+    norm_dir.mkdir(parents=True, exist_ok=True)
+
+    normaliser = IpaNormaliser(cfg.normalisation)
+
+    for jsonl_path in sorted(ingest_dir.glob("*.jsonl")):
+        if jsonl_path.name.startswith("_"):
+            continue
+        logger.info("Normalising %s", jsonl_path.name)
+        out_path = norm_dir / jsonl_path.name
+        count = 0
+        with jsonl_path.open("rb") as fin, out_path.open("wb") as fout:
+            for line in fin:
+                raw = RawLexeme.from_dict(orjson.loads(line))
+                normalised = normaliser.normalise(raw)
+                fout.write(orjson.dumps(normalised.to_dict()) + b"\n")
+                count += 1
+        logger.info("  Wrote %d normalised lexemes to %s", count, out_path)

cognate_pipeline/src/cognate_pipeline/cognate/baseline_levenshtein.py

@@ -0,0 +1,112 @@
+"""Weighted Levenshtein scorer using SCA sound classes."""
+
+from __future__ import annotations
+
+import logging
+from cognate_pipeline.cognate.models import CognateLink
+from cognate_pipeline.normalise.models import NormalisedLexeme
+
+logger = logging.getLogger(__name__)
+
+# Substitution costs between SCA classes (lower = more similar)
+# Same class = 0, vowels among themselves = 0.3, related consonants = 0.5, unrelated = 1.0
+_VOWELS = set("AEIOU")
+_LABIALS = {"P", "B", "M"}
+_CORONALS = {"T", "D", "N", "S", "L", "R"}
+_VELARS = {"K", "G"}
+_LARYNGEALS = {"H"}
+_GLIDES = {"W", "Y"}
+
+_NATURAL_CLASSES = [_VOWELS, _LABIALS, _CORONALS, _VELARS, _LARYNGEALS, _GLIDES]
+
+
+def _substitution_cost(a: str, b: str) -> float:
+    """Compute substitution cost between two SCA class characters."""
+    if a == b:
+        return 0.0
+    # Check if in same natural class
+    for cls in _NATURAL_CLASSES:
+        if a in cls and b in cls:
+            return 0.3
+    return 1.0
+
+
+def weighted_levenshtein(s1: str, s2: str) -> float:
+    """Compute weighted Levenshtein distance using SCA-aware costs.
+
+    Insertion/deletion cost = 0.5, substitution cost varies by class.
+    """
+    n, m = len(s1), len(s2)
+    if n == 0:
+        return m * 0.5
+    if m == 0:
+        return n * 0.5
+
+    dp = [[0.0] * (m + 1) for _ in range(n + 1)]
+    for i in range(n + 1):
+        dp[i][0] = i * 0.5
+    for j in range(m + 1):
+        dp[0][j] = j * 0.5
+
+    for i in range(1, n + 1):
+        for j in range(1, m + 1):
+            sub_cost = _substitution_cost(s1[i - 1], s2[j - 1])
+            dp[i][j] = min(
+                dp[i - 1][j] + 0.5,      # deletion
+                dp[i][j - 1] + 0.5,       # insertion
+                dp[i - 1][j - 1] + sub_cost,  # substitution
+            )
+    return dp[n][m]
+
+
+def normalised_similarity(s1: str, s2: str) -> float:
+    """Compute normalised similarity (0-1) from weighted Levenshtein.
+
+    1.0 = identical, 0.0 = maximally different.
+    """
+    if not s1 and not s2:
+        return 1.0
+    max_len = max(len(s1), len(s2))
+    # Maximum possible distance is max_len * 1.0 (all substitutions at full cost)
+    dist = weighted_levenshtein(s1, s2)
+    return 1.0 - (dist / max_len) if max_len > 0 else 1.0
+
+
+class BaselineLevenshtein:
+    """Baseline cognate detector using weighted Levenshtein on sound classes."""
+
+    def score_pairs(
+        self,
+        pairs: list[tuple[NormalisedLexeme, NormalisedLexeme, str]],
+        threshold: float = 0.5,
+    ) -> list[CognateLink]:
+        """Score all candidate pairs and return links above threshold.
+
+        Each pair is (lexeme_a, lexeme_b, relationship_type).
+        """
+        links: list[CognateLink] = []
+        for a, b, rel_type in pairs:
+            sc_a = a.sound_class
+            sc_b = b.sound_class
+            score = normalised_similarity(sc_a, sc_b)
+            if score >= threshold:
+                # Ensure consistent ordering
+                id_a, id_b = (a.id, b.id) if a.id < b.id else (b.id, a.id)
+                links.append(
+                    CognateLink(
+                        lexeme_id_a=id_a,
+                        lexeme_id_b=id_b,
+                        concept_id=a.concept_id,
+                        relationship_type=rel_type,
+                        score=round(score, 4),
+                        method="baseline_lev",
+                        threshold_used=threshold,
+                        evidence={
+                            "sound_class_a": sc_a,
+                            "sound_class_b": sc_b,
+                            "distance": round(weighted_levenshtein(sc_a, sc_b), 4),
+                        },
+                    )
+                )
+        logger.info("Scored %d pairs, %d above threshold %.2f", len(pairs), len(links), threshold)
+        return links

cognate_pipeline/src/cognate_pipeline/cognate/candidate_gen.py

@@ -0,0 +1,101 @@
+"""Generate cognate candidate pairs from normalised lexemes."""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections import defaultdict
+from itertools import combinations
+from pathlib import Path
+
+from cognate_pipeline.ingest.language_resolver import LanguageResolver
+from cognate_pipeline.normalise.models import NormalisedLexeme
+
+logger = logging.getLogger(__name__)
+
+# Load family map from JSON (generated by scripts/convert_cldf_to_tsv.py).
+# Falls back to a minimal hardcoded map if the JSON is missing.
+_FAMILY_MAP_PATH = Path(__file__).parent / "family_map.json"
+
+_FAMILY_MAP_FALLBACK: dict[str, str] = {
+    "uga": "semitic", "heb": "semitic", "akk": "semitic", "arc": "semitic",
+    "phn": "semitic", "syc": "semitic", "arb": "semitic", "amh": "semitic",
+    "got": "germanic", "ang": "germanic", "non": "germanic", "goh": "germanic",
+    "lat": "italic", "osc": "italic", "xum": "italic",
+    "grc": "hellenic", "gmy": "hellenic",
+    "sga": "celtic", "cym": "celtic", "bre": "celtic",
+    "lit": "balto_slavic", "chu": "balto_slavic", "rus": "balto_slavic",
+    "san": "indo_iranian", "ave": "indo_iranian", "fas": "indo_iranian",
+    "otk": "turkic", "tur": "turkic", "aze": "turkic",
+    "fin": "uralic", "hun": "uralic", "est": "uralic",
+    "sux": "sumerian", "egy": "egyptian", "hit": "anatolian",
+    "xib": "iberian", "eus": "basque",
+}
+
+if _FAMILY_MAP_PATH.exists():
+    with open(_FAMILY_MAP_PATH, encoding="utf-8") as _f:
+        _FAMILY_MAP: dict[str, str] = json.load(_f)
+    logger.debug("Loaded %d family mappings from %s", len(_FAMILY_MAP), _FAMILY_MAP_PATH)
+else:
+    _FAMILY_MAP = _FAMILY_MAP_FALLBACK
+    logger.debug("Using fallback family map (%d entries)", len(_FAMILY_MAP))
+
+
+def _get_family(language_id: str, glottocode: str) -> str:
+    """Resolve a language to its family label."""
+    lid = language_id.lower()
+    if lid in _FAMILY_MAP:
+        return _FAMILY_MAP[lid]
+    return f"unknown_{lid}"
+
+
+def generate_candidates(
+    lexemes: list[NormalisedLexeme],
+    family_aware: bool = False,
+) -> list[tuple[NormalisedLexeme, NormalisedLexeme, str]]:
+    """Generate candidate pairs conditioned on shared concept_id.
+
+    Within each concept group, all cross-language pairs are generated.
+    If family_aware is True, each pair is tagged with a relationship_type:
+      - "cognate_inherited": both languages in the same family
+      - "similarity_only": languages in different families
+
+    Returns:
+        List of (lexeme_a, lexeme_b, relationship_type) tuples
+        with lexeme_a.id < lexeme_b.id.
+    """
+    # Group by concept_id
+    by_concept: dict[str, list[NormalisedLexeme]] = defaultdict(list)
+    for lex in lexemes:
+        if lex.concept_id:
+            by_concept[lex.concept_id].append(lex)
+
+    pairs: list[tuple[NormalisedLexeme, NormalisedLexeme, str]] = []
+    for concept_id, group in by_concept.items():
+        if len(group) < 2:
+            continue
+        for a, b in combinations(group, 2):
+            # Skip same-language pairs
+            if a.language_id == b.language_id:
+                continue
+            # Ensure consistent ordering
+            if a.id > b.id:
+                a, b = b, a
+
+            rel_type = "cognate_candidate"
+            if family_aware:
+                fam_a = _get_family(a.language_id, a.glottocode)
+                fam_b = _get_family(b.language_id, b.glottocode)
+                if fam_a == fam_b:
+                    rel_type = "cognate_inherited"
+                else:
+                    rel_type = "similarity_only"
+
+            pairs.append((a, b, rel_type))
+
+    logger.info(
+        "Generated %d candidate pairs from %d concepts",
+        len(pairs),
+        len(by_concept),
+    )
+    return pairs

cognate_pipeline/src/cognate_pipeline/cognate/clustering.py

@@ -0,0 +1,169 @@
+"""Clustering algorithms for cognate set formation."""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from collections import defaultdict
+
+from cognate_pipeline.cognate.models import CognateLink, CognateSet, CognateSetMember
+from cognate_pipeline.config.schema import ClusteringAlgorithm
+
+logger = logging.getLogger(__name__)
+
+
+def cluster_links(
+    links: list[CognateLink],
+    algorithm: ClusteringAlgorithm = ClusteringAlgorithm.CONNECTED_COMPONENTS,
+) -> list[CognateSet]:
+    """Cluster pairwise CognateLinks into CognateSets."""
+    if algorithm == ClusteringAlgorithm.CONNECTED_COMPONENTS:
+        return _connected_components(links)
+    elif algorithm == ClusteringAlgorithm.UPGMA:
+        return _upgma(links)
+    else:
+        raise ValueError(f"Unknown clustering algorithm: {algorithm}")
+
+
+def _connected_components(links: list[CognateLink]) -> list[CognateSet]:
+    """Form cognate sets via connected components on the link graph."""
+    if not links:
+        return []
+
+    # Build adjacency list grouped by concept
+    by_concept: dict[str, list[CognateLink]] = defaultdict(list)
+    for link in links:
+        by_concept[link.concept_id].append(link)
+
+    sets: list[CognateSet] = []
+
+    for concept_id, concept_links in by_concept.items():
+        # Union-Find
+        parent: dict[str, str] = {}
+
+        def find(x: str) -> str:
+            while parent.get(x, x) != x:
+                parent[x] = parent.get(parent[x], parent[x])
+                x = parent[x]
+            return x
+
+        def union(x: str, y: str) -> None:
+            px, py = find(x), find(y)
+            if px != py:
+                parent[px] = py
+
+        for link in concept_links:
+            parent.setdefault(link.lexeme_id_a, link.lexeme_id_a)
+            parent.setdefault(link.lexeme_id_b, link.lexeme_id_b)
+            union(link.lexeme_id_a, link.lexeme_id_b)
+
+        # Collect components
+        components: dict[str, list[str]] = defaultdict(list)
+        for node in parent:
+            components[find(node)].append(node)
+
+        for members in components.values():
+            if len(members) < 2:
+                continue
+            set_id = f"cs_{uuid.uuid4().hex[:12]}"
+            sets.append(
+                CognateSet(
+                    id=set_id,
+                    concept_id=concept_id,
+                    method="connected_components",
+                    members=[
+                        CognateSetMember(lexeme_id=m) for m in sorted(members)
+                    ],
+                    quality={"size": len(members)},
+                )
+            )
+
+    logger.info("Formed %d cognate sets via connected components", len(sets))
+    return sets
+
+
+def _upgma(links: list[CognateLink]) -> list[CognateSet]:
+    """Form cognate sets via UPGMA hierarchical clustering.
+
+    Uses a simple agglomerative approach: iteratively merge the closest
+    pair of clusters based on average link score.
+    """
+    if not links:
+        return []
+
+    by_concept: dict[str, list[CognateLink]] = defaultdict(list)
+    for link in links:
+        by_concept[link.concept_id].append(link)
+
+    sets: list[CognateSet] = []
+
+    for concept_id, concept_links in by_concept.items():
+        # Build distance matrix
+        nodes: set[str] = set()
+        score_map: dict[tuple[str, str], float] = {}
+        for link in concept_links:
+            nodes.add(link.lexeme_id_a)
+            nodes.add(link.lexeme_id_b)
+            key = (
+                min(link.lexeme_id_a, link.lexeme_id_b),
+                max(link.lexeme_id_a, link.lexeme_id_b),
+            )
+            score_map[key] = link.score
+
+        if len(nodes) < 2:
+            continue
+
+        # Initialize clusters
+        clusters: dict[str, list[str]] = {n: [n] for n in nodes}
+
+        while len(clusters) > 1:
+            # Find best merge (highest average score)
+            best_score = -1.0
+            best_pair = None
+            cluster_ids = list(clusters.keys())
+            for i in range(len(cluster_ids)):
+                for j in range(i + 1, len(cluster_ids)):
+                    ci, cj = cluster_ids[i], cluster_ids[j]
+                    # Average score between clusters
+                    total = 0.0
+                    count = 0
+                    for a in clusters[ci]:
+                        for b in clusters[cj]:
+                            key = (min(a, b), max(a, b))
+                            if key in score_map:
+                                total += score_map[key]
+                                count += 1
+                    avg = total / count if count > 0 else 0.0
+                    if avg > best_score:
+                        best_score = avg
+                        best_pair = (ci, cj)
+
+            if best_pair is None or best_score <= 0:
+                break
+
+            # Merge
+            ci, cj = best_pair
+            merged = clusters[ci] + clusters[cj]
+            new_id = f"{ci}+{cj}"
+            del clusters[ci]
+            del clusters[cj]
+            clusters[new_id] = merged
+
+        for members in clusters.values():
+            if len(members) < 2:
+                continue
+            set_id = f"cs_{uuid.uuid4().hex[:12]}"
+            sets.append(
+                CognateSet(
+                    id=set_id,
+                    concept_id=concept_id,
+                    method="upgma",
+                    members=[
+                        CognateSetMember(lexeme_id=m) for m in sorted(members)
+                    ],
+                    quality={"size": len(members)},
+                )
+            )
+
+    logger.info("Formed %d cognate sets via UPGMA", len(sets))
+    return sets

cognate_pipeline/src/cognate_pipeline/cognate/family_map.json

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

cognate_pipeline/src/cognate_pipeline/cognate/lexstat_detector.py

@@ -0,0 +1,96 @@
+"""LingPy LexStat wrapper for cognate detection."""
+
+from __future__ import annotations
+
+import logging
+import tempfile
+from pathlib import Path
+
+from cognate_pipeline.cognate.models import CognateLink, CognateSet, CognateSetMember
+from cognate_pipeline.normalise.models import NormalisedLexeme
+
+logger = logging.getLogger(__name__)
+
+
+class LexStatDetector:
+    """Wraps LingPy's LexStat for cognate detection.
+
+    Requires the `lingpy` optional dependency.
+    """
+
+    def detect(
+        self,
+        lexemes: list[NormalisedLexeme],
+        threshold: float = 0.5,
+    ) -> list[CognateLink]:
+        """Run LexStat cognate detection on the given lexemes."""
+        try:
+            from lingpy import LexStat
+        except ImportError:
+            raise ImportError(
+                "lingpy is required for LexStat detection. "
+                "Install with: pip install cognate-pipeline[lingpy]"
+            )
+
+        # Build LingPy-format TSV
+        with tempfile.NamedTemporaryFile(
+            mode="w", suffix=".tsv", delete=False, encoding="utf-8"
+        ) as tmp:
+            tmp.write("ID\tDOCULECT\tCONCEPT\tIPA\tTOKENS\n")
+            id_map: dict[int, str] = {}
+            for idx, lex in enumerate(lexemes, start=1):
+                tokens = " ".join(list(lex.ipa_canonical)) if lex.ipa_canonical else lex.form
+                tmp.write(
+                    f"{idx}\t{lex.language_id}\t{lex.concept_id}\t"
+                    f"{lex.ipa_canonical or lex.form}\t{tokens}\n"
+                )
+                id_map[idx] = lex.id
+            tmp_path = tmp.name
+
+        try:
+            lex_stat = LexStat(tmp_path)
+            lex_stat.get_scorer(runs=100)
+            lex_stat.cluster(method="lexstat", threshold=threshold)
+
+            # Extract cognate links from clustering results
+            links: list[CognateLink] = []
+            cogid_col = lex_stat.header.get("cogid", lex_stat.header.get("lexstatid"))
+            if cogid_col is None:
+                logger.warning("No cognate ID column found in LexStat output")
+                return links
+
+            # Group by cogid to find pairs
+            from collections import defaultdict
+
+            cogid_groups: dict[int, list[int]] = defaultdict(list)
+            for idx in lex_stat:
+                cogid = lex_stat[idx, cogid_col]
+                cogid_groups[cogid].append(idx)
+
+            from itertools import combinations
+
+            for cogid, members in cogid_groups.items():
+                if len(members) < 2:
+                    continue
+                concept = lex_stat[members[0], "concept"]
+                for a_idx, b_idx in combinations(members, 2):
+                    id_a = id_map[a_idx]
+                    id_b = id_map[b_idx]
+                    if id_a > id_b:
+                        id_a, id_b = id_b, id_a
+                    links.append(
+                        CognateLink(
+                            lexeme_id_a=id_a,
+                            lexeme_id_b=id_b,
+                            concept_id=concept,
+                            relationship_type="cognate_candidate",
+                            score=1.0,
+                            method="lexstat",
+                            threshold_used=threshold,
+                            evidence={"cogid": cogid},
+                        )
+                    )
+
+            return links
+        finally:
+            Path(tmp_path).unlink(missing_ok=True)

cognate_pipeline/src/cognate_pipeline/cognate/models.py

@@ -0,0 +1,90 @@
+"""Data models for cognate detection and clustering."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class CognateLink:
+    """A scored pairwise cognate relationship between two lexemes."""
+
+    lexeme_id_a: str
+    lexeme_id_b: str
+    concept_id: str
+    relationship_type: str = "cognate_candidate"  # cognate_inherited | similarity_only | cognate_candidate
+    score: float = 0.0
+    method: str = ""
+    threshold_used: float = 0.0
+    evidence: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "lexeme_id_a": self.lexeme_id_a,
+            "lexeme_id_b": self.lexeme_id_b,
+            "concept_id": self.concept_id,
+            "relationship_type": self.relationship_type,
+            "score": self.score,
+            "method": self.method,
+            "threshold_used": self.threshold_used,
+            "evidence": self.evidence,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> CognateLink:
+        return cls(
+            lexeme_id_a=d["lexeme_id_a"],
+            lexeme_id_b=d["lexeme_id_b"],
+            concept_id=d.get("concept_id", ""),
+            relationship_type=d.get("relationship_type", "cognate_candidate"),
+            score=d.get("score", 0.0),
+            method=d.get("method", ""),
+            threshold_used=d.get("threshold_used", 0.0),
+            evidence=d.get("evidence", {}),
+        )
+
+
+@dataclass
+class CognateSetMember:
+    """A member of a cognate set."""
+
+    lexeme_id: str
+    role: str = "member"  # member | proto | reflex
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"lexeme_id": self.lexeme_id, "role": self.role}
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> CognateSetMember:
+        return cls(lexeme_id=d["lexeme_id"], role=d.get("role", "member"))
+
+
+@dataclass
+class CognateSet:
+    """A cluster of cognate lexemes sharing a common etymon."""
+
+    id: str
+    concept_id: str
+    method: str
+    members: list[CognateSetMember] = field(default_factory=list)
+    quality: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "concept_id": self.concept_id,
+            "method": self.method,
+            "members": [m.to_dict() for m in self.members],
+            "quality": self.quality,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> CognateSet:
+        return cls(
+            id=d["id"],
+            concept_id=d.get("concept_id", ""),
+            method=d.get("method", ""),
+            members=[CognateSetMember.from_dict(m) for m in d.get("members", [])],
+            quality=d.get("quality", {}),
+        )

cognate_pipeline/src/cognate_pipeline/config/loader.py

@@ -0,0 +1,19 @@
+"""Load and validate pipeline configuration from YAML."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+from .schema import PipelineConfig
+
+
+def load_config(path: Path | str) -> PipelineConfig:
+    """Read a YAML file and return a validated PipelineConfig."""
+    path = Path(path)
+    with path.open("r", encoding="utf-8") as fh:
+        raw = yaml.safe_load(fh)
+    if raw is None:
+        raw = {}
+    return PipelineConfig.model_validate(raw)

cognate_pipeline/src/cognate_pipeline/config/schema.py

@@ -0,0 +1,109 @@
+"""Pydantic v2 configuration models for the cognate pipeline."""
+
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class CognateMethod(str, Enum):
+    BASELINE_LEV = "baseline_lev"
+    LEXSTAT = "lexstat"
+
+
+class ClusteringAlgorithm(str, Enum):
+    UPGMA = "upgma"
+    CONNECTED_COMPONENTS = "connected_components"
+
+
+class SourceFormat(str, Enum):
+    CLDF = "cldf"
+    CSV = "csv"
+    TSV = "tsv"
+    COG = "cog"
+    JSON = "json"
+    NDJSON = "ndjson"
+    WIKTIONARY = "wiktionary"
+
+
+class DatabaseConfig(BaseModel):
+    host: str = "localhost"
+    port: int = 5432
+    name: str = "cognate_db"
+    user: str = "postgres"
+    password: str = ""
+    schema_name: str = "public"
+
+    @property
+    def url(self) -> str:
+        return (
+            f"postgresql+psycopg://{self.user}:{self.password}"
+            f"@{self.host}:{self.port}/{self.name}"
+        )
+
+
+class ColumnMapping(BaseModel):
+    """Maps source columns to internal fields."""
+
+    language: str = "Language_ID"
+    form: str = "Form"
+    concept: str = "Parameter_ID"
+    ipa: str | None = None
+    glottocode: str | None = None
+    source_id: str | None = None
+
+
+class SourceDef(BaseModel):
+    """Definition of a single data source."""
+
+    name: str
+    path: Path
+    format: SourceFormat
+    license: str = "unknown"
+    license_url: str = ""
+    citation_bibtex: str = ""
+    column_mapping: ColumnMapping = Field(default_factory=ColumnMapping)
+    delimiter: str | None = None
+    encoding: str = "utf-8"
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class NormalisationConfig(BaseModel):
+    unicode_form: str = "NFC"
+    strip_suprasegmentals: bool = False
+    strip_whitespace: bool = True
+    ipa_backend_priority: list[str] = Field(
+        default_factory=lambda: ["attested", "epitran", "phonemizer"]
+    )
+    transliteration_passthrough: bool = True
+
+
+class CognateConfig(BaseModel):
+    method: CognateMethod = CognateMethod.BASELINE_LEV
+    clustering: ClusteringAlgorithm = ClusteringAlgorithm.CONNECTED_COMPONENTS
+    threshold: float = 0.5
+    family_aware: bool = True
+    batch_size: int = 10000
+
+
+class ExportConfig(BaseModel):
+    cldf_output_dir: Path = Path("export/cldf")
+    jsonld_output_dir: Path = Path("export/jsonld")
+    include_provenance: bool = True
+
+
+class PipelineConfig(BaseModel):
+    """Top-level pipeline configuration."""
+
+    staging_dir: Path = Path("staging")
+    sources: list[SourceDef] = Field(default_factory=list)
+    database: DatabaseConfig = Field(default_factory=DatabaseConfig)
+    normalisation: NormalisationConfig = Field(default_factory=NormalisationConfig)
+    cognate: CognateConfig = Field(default_factory=CognateConfig)
+    export: ExportConfig = Field(default_factory=ExportConfig)
+    glottolog_data_dir: Path | None = None
+    batch_size: int = 5000
+    log_level: str = "INFO"

cognate_pipeline/src/cognate_pipeline/db/connection.py

@@ -0,0 +1,29 @@
+"""Database engine and session factory."""
+
+from __future__ import annotations
+
+from sqlalchemy import create_engine, Engine
+from sqlalchemy.orm import Session, sessionmaker
+
+from cognate_pipeline.config.schema import DatabaseConfig
+
+_engine_cache: dict[str, Engine] = {}
+
+
+def get_engine(config: DatabaseConfig) -> Engine:
+    """Get or create a SQLAlchemy engine for the given config."""
+    url = config.url
+    if url not in _engine_cache:
+        _engine_cache[url] = create_engine(
+            url,
+            pool_size=5,
+            max_overflow=10,
+            pool_pre_ping=True,
+        )
+    return _engine_cache[url]
+
+
+def get_session(engine: Engine) -> Session:
+    """Create a new session bound to the given engine."""
+    factory = sessionmaker(bind=engine)
+    return factory()

cognate_pipeline/src/cognate_pipeline/db/loader.py

@@ -0,0 +1,171 @@
+"""Batch data loader for PostgreSQL."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from sqlalchemy import Engine, select, text
+from sqlalchemy.orm import Session, sessionmaker
+
+from cognate_pipeline.db.schema import (
+    Base,
+    CognateLink as CognateLinkTable,
+    CognateSetMember,
+    CognateSetTable,
+    Language,
+    Lexeme,
+    Source,
+)
+from cognate_pipeline.utils.batching import batched
+
+logger = logging.getLogger(__name__)
+
+
+class BatchLoader:
+    """Loads staged data into PostgreSQL in batches."""
+
+    def __init__(self, engine: Engine, batch_size: int = 5000) -> None:
+        self.engine = engine
+        self.batch_size = batch_size
+        self._session_factory = sessionmaker(bind=engine)
+        # Ensure tables exist
+        Base.metadata.create_all(engine)
+
+    def _session(self) -> Session:
+        return self._session_factory()
+
+    def load_sources(self, registry: dict[str, Any]) -> None:
+        """Load source metadata from license registry dict."""
+        with self._session() as session:
+            for source_data in registry.get("sources", {}).values():
+                existing = session.execute(
+                    select(Source).where(Source.source_name == source_data["source_name"])
+                ).scalar_one_or_none()
+                if existing is None:
+                    session.add(Source(
+                        source_name=source_data["source_name"],
+                        license=source_data.get("license", "unknown"),
+                        license_url=source_data.get("license_url", ""),
+                        citation_bibtex=source_data.get("citation_bibtex", ""),
+                    ))
+            session.commit()
+
+    def load_lexemes(self, records: list[dict[str, Any]]) -> None:
+        """Load normalised lexeme records into the database."""
+        with self._session() as session:
+            # Pre-load language and source caches
+            lang_cache: dict[str, int] = {}
+            source_cache: dict[str, int] = {}
+
+            for batch in batched(records, self.batch_size):
+                for rec in batch:
+                    # Ensure language exists
+                    lang_id_str = rec.get("language_id", "")
+                    glottocode = rec.get("glottocode", "") or lang_id_str
+                    if glottocode not in lang_cache:
+                        lang = session.execute(
+                            select(Language).where(Language.glottocode == glottocode)
+                        ).scalar_one_or_none()
+                        if lang is None:
+                            lang = Language(glottocode=glottocode, name=lang_id_str)
+                            session.add(lang)
+                            session.flush()
+                        lang_cache[glottocode] = lang.id
+
+                    # Ensure source exists
+                    source_name = rec.get("source_name", "unknown")
+                    if source_name not in source_cache:
+                        src = session.execute(
+                            select(Source).where(Source.source_name == source_name)
+                        ).scalar_one_or_none()
+                        if src is None:
+                            src = Source(source_name=source_name)
+                            session.add(src)
+                            session.flush()
+                        source_cache[source_name] = src.id
+
+                    session.add(Lexeme(
+                        external_id=rec.get("id", ""),
+                        language_id=lang_cache[glottocode],
+                        source_id=source_cache[source_name],
+                        concept_id=rec.get("concept_id", ""),
+                        lemma=rec.get("form", ""),
+                        orthography=rec.get("form", ""),
+                        phonetic_raw=rec.get("phonetic_raw", rec.get("ipa_raw", "")),
+                        phonetic_canonical=rec.get("phonetic_canonical", rec.get("ipa_canonical", "")),
+                        transcription_type=rec.get("transcription_type", "unknown"),
+                        sound_class=rec.get("sound_class", ""),
+                        confidence=rec.get("confidence", 1.0),
+                        provenance=rec.get("provenance"),
+                    ))
+                session.commit()
+                logger.debug("Committed batch of %d lexemes", len(batch))
+
+    def load_cognate_links(self, links: list[dict[str, Any]]) -> None:
+        """Load cognate link records.
+
+        Note: This requires lexemes to be loaded first, as it needs to
+        resolve external IDs to database IDs.
+        """
+        with self._session() as session:
+            # Build external_id -> db_id mapping
+            id_map: dict[str, int] = {}
+            for lex in session.execute(select(Lexeme)).scalars():
+                id_map[lex.external_id] = lex.id
+
+            # Get default source
+            default_source = session.execute(select(Source)).scalars().first()
+            source_id = default_source.id if default_source else 1
+
+            for batch in batched(links, self.batch_size):
+                for link_data in batch:
+                    db_id_a = id_map.get(link_data["lexeme_id_a"])
+                    db_id_b = id_map.get(link_data["lexeme_id_b"])
+                    if db_id_a is None or db_id_b is None:
+                        continue
+                    # Ensure ordering
+                    if db_id_a > db_id_b:
+                        db_id_a, db_id_b = db_id_b, db_id_a
+                    session.add(CognateLinkTable(
+                        lexeme_id_a=db_id_a,
+                        lexeme_id_b=db_id_b,
+                        source_id=source_id,
+                        concept_id=link_data.get("concept_id", ""),
+                        relationship_type=link_data.get("relationship_type", "cognate_candidate"),
+                        score=link_data.get("score", 0.0),
+                        method=link_data.get("method", ""),
+                        threshold_used=link_data.get("threshold_used", 0.0),
+                        evidence=link_data.get("evidence"),
+                    ))
+                session.commit()
+
+    def load_cognate_sets(self, sets_data: list[dict[str, Any]]) -> None:
+        """Load cognate set records."""
+        with self._session() as session:
+            # Build external_id -> db_id mapping
+            id_map: dict[str, int] = {}
+            for lex in session.execute(select(Lexeme)).scalars():
+                id_map[lex.external_id] = lex.id
+
+            for batch in batched(sets_data, self.batch_size):
+                for set_data in batch:
+                    cs = CognateSetTable(
+                        external_id=set_data.get("id", ""),
+                        concept_id=set_data.get("concept_id", ""),
+                        method=set_data.get("method", ""),
+                        quality=set_data.get("quality"),
+                    )
+                    session.add(cs)
+                    session.flush()
+
+                    for member_data in set_data.get("members", []):
+                        db_id = id_map.get(member_data["lexeme_id"])
+                        if db_id is None:
+                            continue
+                        session.add(CognateSetMember(
+                            cognate_set_id=cs.id,
+                            lexeme_id=db_id,
+                            role=member_data.get("role", "member"),
+                        ))
+                session.commit()

cognate_pipeline/src/cognate_pipeline/db/migrations/env.py

@@ -0,0 +1,49 @@
+"""Alembic environment configuration."""
+
+from __future__ import annotations
+
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+from cognate_pipeline.db.schema import Base
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = Base.metadata
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode."""
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

cognate_pipeline/src/cognate_pipeline/db/migrations/versions/001_initial_schema.py

@@ -0,0 +1,160 @@
+"""Initial schema with all 8 tables.
+
+Revision ID: 001
+Create Date: 2024-01-01 00:00:00.000000
+"""
+
+from __future__ import annotations
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+revision = "001"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # Language table
+    op.create_table(
+        "language",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("glottocode", sa.String(8), nullable=False),
+        sa.Column("name", sa.String(256), nullable=False, server_default=""),
+        sa.Column("iso639_3", sa.String(3), nullable=True),
+        sa.Column("family_glottocode", sa.String(8), nullable=True),
+        sa.Column("classification_path", postgresql.ARRAY(sa.Text()), nullable=True),
+        sa.Column("metadata", postgresql.JSONB(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("glottocode"),
+    )
+    op.execute("SELECT AddGeometryColumn('language', 'location', 4326, 'POINT', 2)")
+
+    # Source table
+    op.create_table(
+        "source",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("source_name", sa.String(256), nullable=False),
+        sa.Column("license", sa.String(128), nullable=False, server_default="unknown"),
+        sa.Column("license_url", sa.Text(), nullable=False, server_default=""),
+        sa.Column("citation_bibtex", sa.Text(), nullable=False, server_default=""),
+        sa.Column("retrieved_at", sa.DateTime(timezone=True), nullable=False, server_default=sa.func.now()),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("source_name"),
+    )
+
+    # Lexeme table
+    op.create_table(
+        "lexeme",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("external_id", sa.String(256), nullable=False, server_default=""),
+        sa.Column("language_id", sa.Integer(), nullable=False),
+        sa.Column("source_id", sa.Integer(), nullable=False),
+        sa.Column("concept_id", sa.String(256), nullable=False, server_default=""),
+        sa.Column("lemma", sa.String(512), nullable=False),
+        sa.Column("orthography", sa.String(512), nullable=False, server_default=""),
+        sa.Column("ipa_raw", sa.Text(), nullable=False, server_default=""),
+        sa.Column("ipa_canonical", sa.Text(), nullable=False, server_default=""),
+        sa.Column("sound_class", sa.String(512), nullable=False, server_default=""),
+        sa.Column("confidence", sa.Float(), nullable=False, server_default="1.0"),
+        sa.Column("provenance", postgresql.JSONB(), nullable=True),
+        sa.ForeignKeyConstraint(["language_id"], ["language.id"]),
+        sa.ForeignKeyConstraint(["source_id"], ["source.id"]),
+        sa.PrimaryKeyConstraint("id"),
+        sa.CheckConstraint("confidence >= 0 AND confidence <= 1", name="ck_lexeme_confidence"),
+    )
+    op.create_index("ix_lexeme_concept", "lexeme", ["concept_id"])
+    op.create_index("ix_lexeme_language", "lexeme", ["language_id"])
+
+    # Name entity table
+    op.create_table(
+        "name_entity",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("entity_type", sa.String(64), nullable=False),
+        sa.Column("external_ids", postgresql.JSONB(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.CheckConstraint(
+            "entity_type IN ('place', 'person', 'deity', 'ethnonym', 'other')",
+            name="ck_entity_type",
+        ),
+    )
+    op.execute("SELECT AddGeometryColumn('name_entity', 'location', 4326, 'POINT', 2)")
+
+    # Name form table
+    op.create_table(
+        "name_form",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("name_entity_id", sa.Integer(), nullable=False),
+        sa.Column("language_id", sa.Integer(), nullable=False),
+        sa.Column("source_id", sa.Integer(), nullable=False),
+        sa.Column("name_string", sa.String(512), nullable=False),
+        sa.Column("ipa_raw", sa.Text(), nullable=False, server_default=""),
+        sa.Column("ipa_canonical", sa.Text(), nullable=False, server_default=""),
+        sa.Column("provenance", postgresql.JSONB(), nullable=True),
+        sa.ForeignKeyConstraint(["name_entity_id"], ["name_entity.id"]),
+        sa.ForeignKeyConstraint(["language_id"], ["language.id"]),
+        sa.ForeignKeyConstraint(["source_id"], ["source.id"]),
+        sa.PrimaryKeyConstraint("id"),
+    )
+
+    # Cognate link table
+    op.create_table(
+        "cognate_link",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("lexeme_id_a", sa.Integer(), nullable=False),
+        sa.Column("lexeme_id_b", sa.Integer(), nullable=False),
+        sa.Column("source_id", sa.Integer(), nullable=False),
+        sa.Column("concept_id", sa.String(256), nullable=False, server_default=""),
+        sa.Column("relationship_type", sa.String(64), nullable=False, server_default="cognate_candidate"),
+        sa.Column("score", sa.Float(), nullable=False, server_default="0.0"),
+        sa.Column("method", sa.String(64), nullable=False, server_default=""),
+        sa.Column("threshold_used", sa.Float(), nullable=False, server_default="0.0"),
+        sa.Column("evidence", postgresql.JSONB(), nullable=True),
+        sa.ForeignKeyConstraint(["lexeme_id_a"], ["lexeme.id"]),
+        sa.ForeignKeyConstraint(["lexeme_id_b"], ["lexeme.id"]),
+        sa.ForeignKeyConstraint(["source_id"], ["source.id"]),
+        sa.PrimaryKeyConstraint("id"),
+        sa.CheckConstraint("lexeme_id_a < lexeme_id_b", name="ck_link_ordering"),
+        sa.CheckConstraint(
+            "relationship_type IN ('cognate_inherited', 'similarity_only', 'cognate_candidate', 'borrowing')",
+            name="ck_relationship_type",
+        ),
+        sa.UniqueConstraint("lexeme_id_a", "lexeme_id_b", "method", name="uq_link_pair_method"),
+    )
+    op.create_index("ix_cognate_link_concept", "cognate_link", ["concept_id"])
+
+    # Cognate set table
+    op.create_table(
+        "cognate_set",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("external_id", sa.String(256), nullable=False, server_default=""),
+        sa.Column("concept_id", sa.String(256), nullable=False, server_default=""),
+        sa.Column("method", sa.String(64), nullable=False, server_default=""),
+        sa.Column("quality", postgresql.JSONB(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index("ix_cognate_set_concept", "cognate_set", ["concept_id"])
+
+    # Cognate set member table
+    op.create_table(
+        "cognate_set_member",
+        sa.Column("cognate_set_id", sa.Integer(), nullable=False),
+        sa.Column("lexeme_id", sa.Integer(), nullable=False),
+        sa.Column("role", sa.String(32), nullable=False, server_default="member"),
+        sa.ForeignKeyConstraint(["cognate_set_id"], ["cognate_set.id"]),
+        sa.ForeignKeyConstraint(["lexeme_id"], ["lexeme.id"]),
+        sa.PrimaryKeyConstraint("cognate_set_id", "lexeme_id"),
+    )
+
+
+def downgrade() -> None:
+    op.drop_table("cognate_set_member")
+    op.drop_table("cognate_set")
+    op.drop_table("cognate_link")
+    op.drop_table("name_form")
+    op.drop_table("name_entity")
+    op.drop_table("lexeme")
+    op.drop_table("source")
+    op.drop_table("language")

cognate_pipeline/src/cognate_pipeline/db/schema.py

@@ -0,0 +1,191 @@
+"""SQLAlchemy 2.0 ORM models for the cognate pipeline database.
+
+8 tables:
+  - language
+  - source
+  - lexeme
+  - name_entity
+  - name_form
+  - cognate_link
+  - cognate_set
+  - cognate_set_member
+"""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime, timezone
+
+from sqlalchemy import (
+    CheckConstraint,
+    Column,
+    DateTime,
+    Float,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Text,
+    UniqueConstraint,
+)
+from sqlalchemy.dialects.postgresql import ARRAY, JSONB, UUID
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from geoalchemy2 import Geometry
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Language(Base):
+    __tablename__ = "language"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    glottocode: Mapped[str] = mapped_column(String(8), unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(String(256), nullable=False, default="")
+    iso639_3: Mapped[str | None] = mapped_column(String(3), nullable=True)
+    family_glottocode: Mapped[str | None] = mapped_column(String(8), nullable=True)
+    classification_path = mapped_column(ARRAY(Text), nullable=True)
+    location = mapped_column(Geometry("POINT", srid=4326), nullable=True)
+    metadata_ = mapped_column("metadata", JSONB, nullable=True)
+
+    lexemes: Mapped[list[Lexeme]] = relationship(back_populates="language")
+    name_forms: Mapped[list[NameForm]] = relationship(back_populates="language")
+
+
+class Source(Base):
+    __tablename__ = "source"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    source_name: Mapped[str] = mapped_column(String(256), unique=True, nullable=False)
+    license: Mapped[str] = mapped_column(String(128), nullable=False, default="unknown")
+    license_url: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    citation_bibtex: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    retrieved_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, default=lambda: datetime.now(timezone.utc)
+    )
+
+    lexemes: Mapped[list[Lexeme]] = relationship(back_populates="source")
+    name_forms: Mapped[list[NameForm]] = relationship(back_populates="source")
+    cognate_links: Mapped[list[CognateLink]] = relationship(back_populates="source")
+
+
+class Lexeme(Base):
+    __tablename__ = "lexeme"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    external_id: Mapped[str] = mapped_column(String(256), nullable=False, default="")
+    language_id: Mapped[int] = mapped_column(ForeignKey("language.id"), nullable=False)
+    source_id: Mapped[int] = mapped_column(ForeignKey("source.id"), nullable=False)
+    concept_id: Mapped[str] = mapped_column(String(256), nullable=False, default="")
+    lemma: Mapped[str] = mapped_column(String(512), nullable=False)
+    orthography: Mapped[str] = mapped_column(String(512), nullable=False, default="")
+    phonetic_raw: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    phonetic_canonical: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    transcription_type: Mapped[str] = mapped_column(
+        String(32), nullable=False, default="unknown"
+    )
+    sound_class: Mapped[str] = mapped_column(String(512), nullable=False, default="")
+    confidence: Mapped[float] = mapped_column(Float, nullable=False, default=1.0)
+    provenance = mapped_column(JSONB, nullable=True)
+
+    language: Mapped[Language] = relationship(back_populates="lexemes")
+    source: Mapped[Source] = relationship(back_populates="lexemes")
+
+    __table_args__ = (
+        Index("ix_lexeme_concept", "concept_id"),
+        Index("ix_lexeme_language", "language_id"),
+        CheckConstraint("confidence >= 0 AND confidence <= 1", name="ck_lexeme_confidence"),
+    )
+
+
+class NameEntity(Base):
+    __tablename__ = "name_entity"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    entity_type: Mapped[str] = mapped_column(String(64), nullable=False)
+    external_ids = mapped_column(JSONB, nullable=True)
+    location = mapped_column(Geometry("POINT", srid=4326), nullable=True)
+
+    name_forms: Mapped[list[NameForm]] = relationship(back_populates="name_entity")
+
+    __table_args__ = (
+        CheckConstraint(
+            "entity_type IN ('place', 'person', 'deity', 'ethnonym', 'other')",
+            name="ck_entity_type",
+        ),
+    )
+
+
+class NameForm(Base):
+    __tablename__ = "name_form"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    name_entity_id: Mapped[int] = mapped_column(ForeignKey("name_entity.id"), nullable=False)
+    language_id: Mapped[int] = mapped_column(ForeignKey("language.id"), nullable=False)
+    source_id: Mapped[int] = mapped_column(ForeignKey("source.id"), nullable=False)
+    name_string: Mapped[str] = mapped_column(String(512), nullable=False)
+    ipa_raw: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    ipa_canonical: Mapped[str] = mapped_column(Text, nullable=False, default="")
+    provenance = mapped_column(JSONB, nullable=True)
+
+    name_entity: Mapped[NameEntity] = relationship(back_populates="name_forms")
+    language: Mapped[Language] = relationship(back_populates="name_forms")
+    source: Mapped[Source] = relationship(back_populates="name_forms")
+
+
+class CognateLink(Base):
+    __tablename__ = "cognate_link"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    lexeme_id_a: Mapped[int] = mapped_column(ForeignKey("lexeme.id"), nullable=False)
+    lexeme_id_b: Mapped[int] = mapped_column(ForeignKey("lexeme.id"), nullable=False)
+    source_id: Mapped[int] = mapped_column(ForeignKey("source.id"), nullable=False)
+    concept_id: Mapped[str] = mapped_column(String(256), nullable=False, default="")
+    relationship_type: Mapped[str] = mapped_column(String(64), nullable=False, default="cognate_candidate")
+    score: Mapped[float] = mapped_column(Float, nullable=False, default=0.0)
+    method: Mapped[str] = mapped_column(String(64), nullable=False, default="")
+    threshold_used: Mapped[float] = mapped_column(Float, nullable=False, default=0.0)
+    evidence = mapped_column(JSONB, nullable=True)
+
+    source: Mapped[Source] = relationship(back_populates="cognate_links")
+
+    __table_args__ = (
+        CheckConstraint("lexeme_id_a < lexeme_id_b", name="ck_link_ordering"),
+        CheckConstraint(
+            "relationship_type IN ('cognate_inherited', 'similarity_only', 'cognate_candidate', 'borrowing')",
+            name="ck_relationship_type",
+        ),
+        UniqueConstraint("lexeme_id_a", "lexeme_id_b", "method", name="uq_link_pair_method"),
+        Index("ix_cognate_link_concept", "concept_id"),
+    )
+
+
+class CognateSetTable(Base):
+    __tablename__ = "cognate_set"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    external_id: Mapped[str] = mapped_column(String(256), nullable=False, default="")
+    concept_id: Mapped[str] = mapped_column(String(256), nullable=False, default="")
+    method: Mapped[str] = mapped_column(String(64), nullable=False, default="")
+    quality = mapped_column(JSONB, nullable=True)
+
+    members: Mapped[list[CognateSetMember]] = relationship(back_populates="cognate_set")
+
+    __table_args__ = (
+        Index("ix_cognate_set_concept", "concept_id"),
+    )
+
+
+class CognateSetMember(Base):
+    __tablename__ = "cognate_set_member"
+
+    cognate_set_id: Mapped[int] = mapped_column(
+        ForeignKey("cognate_set.id"), primary_key=True
+    )
+    lexeme_id: Mapped[int] = mapped_column(
+        ForeignKey("lexeme.id"), primary_key=True
+    )
+    role: Mapped[str] = mapped_column(String(32), nullable=False, default="member")
+
+    cognate_set: Mapped[CognateSetTable] = relationship(back_populates="members")

cognate_pipeline/src/cognate_pipeline/export/cldf_exporter.py

@@ -0,0 +1,152 @@
+"""Export database contents as CLDF Wordlist."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import Engine, select
+from sqlalchemy.orm import Session, sessionmaker
+
+from cognate_pipeline.config.schema import ExportConfig
+from cognate_pipeline.db.schema import (
+    CognateSetMember,
+    CognateSetTable,
+    Language,
+    Lexeme,
+    Source,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class CldfExporter:
+    """Exports database contents as a CLDF Wordlist dataset."""
+
+    def __init__(self, engine: Engine, config: ExportConfig) -> None:
+        self.engine = engine
+        self.config = config
+        self._session_factory = sessionmaker(bind=engine)
+
+    def export(self, output_dir: Path) -> None:
+        """Export CLDF files to the given directory."""
+        try:
+            from pycldf import Wordlist
+        except ImportError:
+            # Fallback: write CSV manually
+            self._export_csv_fallback(output_dir)
+            return
+
+        ds = Wordlist.in_dir(output_dir)
+        ds.add_component("LanguageTable")
+        ds.add_component("ParameterTable")
+        ds.add_component("CognateTable")
+
+        with self._session_factory() as session:
+            # Languages
+            languages = list(session.execute(select(Language)).scalars())
+            for lang in languages:
+                ds.add_language(
+                    ID=lang.glottocode,
+                    Name=lang.name,
+                    Glottocode=lang.glottocode,
+                    ISO639P3code=lang.iso639_3 or "",
+                )
+
+            # Lexemes -> Forms + Parameters
+            concepts_seen: set[str] = set()
+            lexemes = list(session.execute(select(Lexeme)).scalars())
+            for lex in lexemes:
+                if lex.concept_id and lex.concept_id not in concepts_seen:
+                    ds.add_concept(ID=lex.concept_id, Name=lex.concept_id)
+                    concepts_seen.add(lex.concept_id)
+
+                lang = session.get(Language, lex.language_id)
+                segments = list(lex.phonetic_canonical) if lex.phonetic_canonical else []
+                ds.add_form(
+                    ID=str(lex.id),
+                    Language_ID=lang.glottocode if lang else "",
+                    Parameter_ID=lex.concept_id,
+                    Form=lex.lemma,
+                    Segments=segments,
+                )
+
+            # Cognate sets
+            cog_sets = list(session.execute(select(CognateSetTable)).scalars())
+            for cs in cog_sets:
+                members = list(
+                    session.execute(
+                        select(CognateSetMember).where(
+                            CognateSetMember.cognate_set_id == cs.id
+                        )
+                    ).scalars()
+                )
+                for member in members:
+                    ds.add_cognate(
+                        ID=f"cog_{cs.id}_{member.lexeme_id}",
+                        Form_ID=str(member.lexeme_id),
+                        Cognateset_ID=str(cs.id),
+                    )
+
+        ds.write()
+        logger.info("CLDF export complete: %s", output_dir)
+
+    def _export_csv_fallback(self, output_dir: Path) -> None:
+        """Export as plain CSV when pycldf is not available."""
+        import csv
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        with self._session_factory() as session:
+            # Languages
+            languages = list(session.execute(select(Language)).scalars())
+            with (output_dir / "languages.csv").open("w", newline="", encoding="utf-8") as f:
+                writer = csv.writer(f)
+                writer.writerow(["ID", "Name", "Glottocode", "ISO639P3code"])
+                for lang in languages:
+                    writer.writerow([lang.glottocode, lang.name, lang.glottocode, lang.iso639_3 or ""])
+
+            # Forms
+            lexemes = list(session.execute(select(Lexeme)).scalars())
+            concepts: set[str] = set()
+            with (output_dir / "forms.csv").open("w", newline="", encoding="utf-8") as f:
+                writer = csv.writer(f)
+                writer.writerow(["ID", "Language_ID", "Parameter_ID", "Form", "Segments"])
+                for lex in lexemes:
+                    lang = session.get(Language, lex.language_id)
+                    segments = " ".join(list(lex.phonetic_canonical)) if lex.phonetic_canonical else ""
+                    writer.writerow([
+                        lex.id,
+                        lang.glottocode if lang else "",
+                        lex.concept_id,
+                        lex.lemma,
+                        segments,
+                    ])
+                    if lex.concept_id:
+                        concepts.add(lex.concept_id)
+
+            # Parameters
+            with (output_dir / "parameters.csv").open("w", newline="", encoding="utf-8") as f:
+                writer = csv.writer(f)
+                writer.writerow(["ID", "Name"])
+                for c in sorted(concepts):
+                    writer.writerow([c, c])
+
+            # Cognates
+            cog_sets = list(session.execute(select(CognateSetTable)).scalars())
+            with (output_dir / "cognates.csv").open("w", newline="", encoding="utf-8") as f:
+                writer = csv.writer(f)
+                writer.writerow(["ID", "Form_ID", "Cognateset_ID"])
+                for cs in cog_sets:
+                    members = list(
+                        session.execute(
+                            select(CognateSetMember).where(
+                                CognateSetMember.cognate_set_id == cs.id
+                            )
+                        ).scalars()
+                    )
+                    for member in members:
+                        writer.writerow([f"cog_{cs.id}_{member.lexeme_id}", member.lexeme_id, cs.id])
+
+        logger.info("CSV fallback export complete: %s", output_dir)

cognate_pipeline/src/cognate_pipeline/export/jsonld_exporter.py

@@ -0,0 +1,138 @@
+"""Export cognate links as JSON-LD."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import orjson
+from sqlalchemy import Engine, select
+from sqlalchemy.orm import Session, sessionmaker
+
+from cognate_pipeline.config.schema import ExportConfig
+from cognate_pipeline.db.schema import (
+    CognateLink,
+    CognateSetMember,
+    CognateSetTable,
+    Language,
+    Lexeme,
+)
+
+logger = logging.getLogger(__name__)
+
+_CONTEXT = {
+    "@context": {
+        "ontolex": "http://www.w3.org/ns/lemon/ontolex#",
+        "lexinfo": "http://www.lexinfo.net/ontology/3.0/lexinfo#",
+        "glottolog": "https://glottolog.org/resource/languoid/id/",
+        "concepticon": "https://concepticon.clld.org/parameters/",
+        "cognate": "http://example.org/cognate#",
+        "lexeme": "cognate:lexeme",
+        "form": "ontolex:writtenRep",
+        "language": "lexinfo:language",
+        "glottocode": "glottolog:",
+        "concept": "concepticon:",
+        "ipa": "ontolex:phoneticRep",
+        "soundClass": "cognate:soundClass",
+        "cognateLink": "cognate:CognateLink",
+        "score": "cognate:score",
+        "method": "cognate:method",
+        "evidence": "cognate:evidence",
+    }
+}
+
+
+class JsonLdExporter:
+    """Exports cognate links as JSON-LD."""
+
+    def __init__(self, engine: Engine, config: ExportConfig) -> None:
+        self.engine = engine
+        self.config = config
+        self._session_factory = sessionmaker(bind=engine)
+
+    def export(self, output_dir: Path) -> None:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        with self._session_factory() as session:
+            # Build lexeme nodes
+            lexeme_nodes = self._build_lexeme_nodes(session)
+
+            # Build cognate link edges
+            link_edges = self._build_link_edges(session)
+
+            # Build cognate sets
+            set_nodes = self._build_set_nodes(session)
+
+        doc: dict[str, Any] = {
+            **_CONTEXT,
+            "@graph": {
+                "lexemes": lexeme_nodes,
+                "cognateLinks": link_edges,
+                "cognateSets": set_nodes,
+            },
+        }
+
+        out_path = output_dir / "cognates.jsonld"
+        out_path.write_bytes(orjson.dumps(doc, option=orjson.OPT_INDENT_2))
+        logger.info("JSON-LD export written to %s", out_path)
+
+    def _build_lexeme_nodes(self, session: Session) -> list[dict]:
+        nodes = []
+        for lex in session.execute(select(Lexeme)).scalars():
+            lang = session.get(Language, lex.language_id)
+            node: dict[str, Any] = {
+                "@id": f"lexeme:{lex.id}",
+                "@type": "lexeme",
+                "externalId": lex.external_id,
+                "form": lex.lemma,
+                "language": lang.glottocode if lang else "",
+                "concept": lex.concept_id,
+                "phoneticCanonical": lex.phonetic_canonical,
+                "transcriptionType": lex.transcription_type,
+                "soundClass": lex.sound_class,
+                "confidence": lex.confidence,
+            }
+            if self.config.include_provenance and lex.provenance:
+                node["provenance"] = lex.provenance
+            nodes.append(node)
+        return nodes
+
+    def _build_link_edges(self, session: Session) -> list[dict]:
+        edges = []
+        for link in session.execute(select(CognateLink)).scalars():
+            edge: dict[str, Any] = {
+                "@type": "cognateLink",
+                "lexemeA": f"lexeme:{link.lexeme_id_a}",
+                "lexemeB": f"lexeme:{link.lexeme_id_b}",
+                "concept": link.concept_id,
+                "relationshipType": link.relationship_type,
+                "score": link.score,
+                "method": link.method,
+            }
+            if link.evidence:
+                edge["evidence"] = link.evidence
+            edges.append(edge)
+        return edges
+
+    def _build_set_nodes(self, session: Session) -> list[dict]:
+        sets = []
+        for cs in session.execute(select(CognateSetTable)).scalars():
+            members = list(
+                session.execute(
+                    select(CognateSetMember).where(
+                        CognateSetMember.cognate_set_id == cs.id
+                    )
+                ).scalars()
+            )
+            sets.append({
+                "@id": f"cognateSet:{cs.id}",
+                "concept": cs.concept_id,
+                "method": cs.method,
+                "members": [
+                    {"lexeme": f"lexeme:{m.lexeme_id}", "role": m.role}
+                    for m in members
+                ],
+                "quality": cs.quality,
+            })
+        return sets

cognate_pipeline/src/cognate_pipeline/ingest/base.py

@@ -0,0 +1,20 @@
+"""Base protocol for source ingesters."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Protocol, runtime_checkable
+
+from cognate_pipeline.config.schema import SourceDef
+from cognate_pipeline.ingest.models import RawLexeme
+
+
+@runtime_checkable
+class SourceIngester(Protocol):
+    """Protocol that all ingesters must implement."""
+
+    def __init__(self, source_def: SourceDef) -> None: ...
+
+    def ingest(self) -> Iterator[RawLexeme]:
+        """Yield RawLexeme objects from the source."""
+        ...

cognate_pipeline/src/cognate_pipeline/ingest/cldf_ingester.py

@@ -0,0 +1,89 @@
+"""CLDF FormTable ingester using pycldf."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterator
+
+from cognate_pipeline.config.schema import SourceDef
+from cognate_pipeline.ingest.models import RawLexeme, TranscriptionType
+from cognate_pipeline.provenance.tracker import ProvenanceRecord
+
+logger = logging.getLogger(__name__)
+
+
+class CldfIngester:
+    """Ingests CLDF Wordlist datasets via pycldf."""
+
+    def __init__(self, source_def: SourceDef) -> None:
+        self.source_def = source_def
+
+    def ingest(self) -> Iterator[RawLexeme]:
+        try:
+            from pycldf import Dataset
+        except ImportError:
+            raise ImportError(
+                "pycldf is required for CLDF ingestion. "
+                "Install with: pip install cognate-pipeline[cldf]"
+            )
+
+        path = self.source_def.path
+        # Find metadata file
+        metadata_path = path / "Wordlist-metadata.json"
+        if not metadata_path.exists():
+            # Try cldf-metadata.json
+            metadata_path = path / "cldf-metadata.json"
+        if not metadata_path.exists():
+            raise FileNotFoundError(
+                f"No CLDF metadata found in {path}. "
+                "Expected Wordlist-metadata.json or cldf-metadata.json"
+            )
+
+        ds = Dataset.from_metadata(metadata_path)
+
+        # Build language_id -> glottocode mapping
+        lang_map: dict[str, str] = {}
+        if "LanguageTable" in ds:
+            for lang in ds["LanguageTable"]:
+                lid = lang.get("ID", "")
+                glottocode = lang.get("Glottocode", "")
+                lang_map[lid] = glottocode
+
+        # Read forms
+        for form in ds["FormTable"]:
+            form_id = str(form.get("ID", ""))
+            language_id = str(form.get("Language_ID", ""))
+            concept_id = str(form.get("Parameter_ID", ""))
+            value = str(form.get("Form", ""))
+
+            if not value or value == "_":
+                continue
+
+            glottocode = lang_map.get(language_id, "")
+
+            # Segments in CLDF are typically IPA tokenisations
+            segments = form.get("Segments", [])
+            phonetic_raw = ""
+            transcription_type = TranscriptionType.UNKNOWN
+            if segments:
+                if isinstance(segments, list):
+                    phonetic_raw = " ".join(segments)
+                else:
+                    phonetic_raw = str(segments)
+                transcription_type = TranscriptionType.IPA
+
+            yield RawLexeme(
+                id=form_id or f"{self.source_def.name}_{language_id}_{concept_id}",
+                language_id=language_id,
+                glottocode=glottocode,
+                concept_id=concept_id,
+                form=value,
+                phonetic_raw=phonetic_raw,
+                transcription_type=transcription_type,
+                source_name=self.source_def.name,
+                provenance=ProvenanceRecord(
+                    source_name=self.source_def.name,
+                    source_format="cldf",
+                    original_id=form_id,
+                ).add_step("ingest", {"dataset": str(path)}),
+            )

cognate_pipeline/src/cognate_pipeline/ingest/csv_ingester.py

@@ -0,0 +1,164 @@
+"""CSV/TSV/COG file ingester with configurable column mapping."""
+
+from __future__ import annotations
+
+import csv
+import logging
+from collections.abc import Iterator
+from pathlib import Path
+
+from cognate_pipeline.config.schema import SourceDef, SourceFormat
+from cognate_pipeline.ingest.models import RawLexeme, TranscriptionType
+from cognate_pipeline.provenance.tracker import ProvenanceRecord
+
+logger = logging.getLogger(__name__)
+
+
+class CsvIngester:
+    """Ingests CSV, TSV, and .cog (cognate pair) files."""
+
+    def __init__(self, source_def: SourceDef) -> None:
+        self.source_def = source_def
+
+    def ingest(self) -> Iterator[RawLexeme]:
+        fmt = self.source_def.format
+        if fmt in (SourceFormat.COG, SourceFormat.TSV):
+            delimiter = self.source_def.delimiter or "\t"
+        else:
+            delimiter = self.source_def.delimiter or ","
+
+        path = Path(self.source_def.path)
+        if fmt == SourceFormat.COG:
+            yield from self._ingest_cog(path, delimiter)
+        else:
+            yield from self._ingest_tabular(path, delimiter)
+
+    def _ingest_cog(self, path: Path, delimiter: str) -> Iterator[RawLexeme]:
+        """Ingest .cog format: two-column cognate pair file.
+
+        Each row has (lang_a_form, lang_b_form).
+        lang_b_form may contain pipe-separated alternatives.
+        `_` represents null / missing.
+
+        These files use consonantal transliteration, NOT IPA.
+        """
+        extra = self.source_def.extra
+        lang_a = extra.get("lang_a", "lang_a")
+        lang_b = extra.get("lang_b", "lang_b")
+
+        with path.open("r", encoding=self.source_def.encoding) as fh:
+            reader = csv.reader(fh, delimiter=delimiter)
+            header = next(reader, None)
+            if header is None:
+                return
+
+            for row_idx, row in enumerate(reader, start=1):
+                if len(row) < 2:
+                    continue
+                form_a = row[0].strip()
+                form_b_raw = row[1].strip()
+
+                # Skip null entries
+                if form_a == "_" or not form_a:
+                    continue
+
+                # Generate a concept_id from the pair (the cognate pair itself)
+                concept_id = f"pair_{row_idx}"
+
+                # Emit lang_a form
+                yield RawLexeme(
+                    id=f"{self.source_def.name}_{lang_a}_{row_idx}",
+                    language_id=lang_a,
+                    glottocode="",
+                    concept_id=concept_id,
+                    form=form_a,
+                    transcription_type=TranscriptionType.TRANSLITERATION,
+                    source_name=self.source_def.name,
+                    provenance=ProvenanceRecord(
+                        source_name=self.source_def.name,
+                        source_format="cog",
+                        original_id=f"row_{row_idx}_col_a",
+                    ).add_step("ingest", {"file": path.name, "row": row_idx}),
+                )
+
+                # Emit lang_b forms (pipe-separated alternatives)
+                if form_b_raw == "_" or not form_b_raw:
+                    continue
+                alternatives = [f.strip() for f in form_b_raw.split("|") if f.strip() and f.strip() != "_"]
+                if not alternatives:
+                    continue
+
+                primary = alternatives[0]
+                rest = alternatives[1:] if len(alternatives) > 1 else []
+                yield RawLexeme(
+                    id=f"{self.source_def.name}_{lang_b}_{row_idx}",
+                    language_id=lang_b,
+                    glottocode="",
+                    concept_id=concept_id,
+                    form=primary,
+                    alternatives=rest,
+                    transcription_type=TranscriptionType.TRANSLITERATION,
+                    source_name=self.source_def.name,
+                    provenance=ProvenanceRecord(
+                        source_name=self.source_def.name,
+                        source_format="cog",
+                        original_id=f"row_{row_idx}_col_b",
+                    ).add_step("ingest", {"file": path.name, "row": row_idx}),
+                )
+
+    def _ingest_tabular(self, path: Path, delimiter: str) -> Iterator[RawLexeme]:
+        """Ingest standard CSV/TSV with column mapping."""
+        mapping = self.source_def.column_mapping
+
+        with path.open("r", encoding=self.source_def.encoding) as fh:
+            reader = csv.DictReader(fh, delimiter=delimiter)
+            for row_idx, row in enumerate(reader, start=1):
+                form_col = mapping.form or "Form"
+                form = row.get(form_col, "").strip()
+                if not form or form == "_":
+                    continue
+
+                lang_col = mapping.language or "Language_ID"
+                language_id = row.get(lang_col, "").strip()
+
+                concept_col = mapping.concept or "Parameter_ID"
+                concept_id = row.get(concept_col, "").strip()
+
+                glottocode = ""
+                if mapping.glottocode:
+                    glottocode = row.get(mapping.glottocode, "").strip()
+
+                phonetic_raw = ""
+                transcription_type = TranscriptionType.UNKNOWN
+                if mapping.ipa:
+                    phonetic_raw = row.get(mapping.ipa, "").strip()
+                    if phonetic_raw:
+                        transcription_type = TranscriptionType.IPA
+
+                # Handle pipe-separated alternatives in form
+                alternatives = []
+                if "|" in form:
+                    parts = [p.strip() for p in form.split("|") if p.strip()]
+                    form = parts[0]
+                    alternatives = parts[1:]
+
+                source_id = ""
+                if mapping.source_id:
+                    source_id = row.get(mapping.source_id, "").strip()
+
+                yield RawLexeme(
+                    id=source_id or f"{self.source_def.name}_{row_idx}",
+                    language_id=language_id,
+                    glottocode=glottocode,
+                    concept_id=concept_id,
+                    form=form,
+                    phonetic_raw=phonetic_raw,
+                    transcription_type=transcription_type,
+                    alternatives=alternatives,
+                    source_name=self.source_def.name,
+                    provenance=ProvenanceRecord(
+                        source_name=self.source_def.name,
+                        source_format=self.source_def.format.value,
+                        original_id=source_id or f"row_{row_idx}",
+                    ).add_step("ingest", {"file": path.name, "row": row_idx}),
+                )

cognate_pipeline/src/cognate_pipeline/ingest/json_ingester.py

@@ -0,0 +1,114 @@
+"""Generic JSON/NDJSON ingester with field mapping."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterator
+from pathlib import Path
+
+import orjson
+
+from cognate_pipeline.config.schema import SourceDef, SourceFormat
+from cognate_pipeline.ingest.models import RawLexeme, TranscriptionType
+from cognate_pipeline.provenance.tracker import ProvenanceRecord
+
+logger = logging.getLogger(__name__)
+
+
+class JsonIngester:
+    """Ingests JSON arrays or NDJSON files with configurable field mapping."""
+
+    def __init__(self, source_def: SourceDef) -> None:
+        self.source_def = source_def
+
+    def ingest(self) -> Iterator[RawLexeme]:
+        path = Path(self.source_def.path)
+        if self.source_def.format == SourceFormat.NDJSON:
+            yield from self._ingest_ndjson(path)
+        else:
+            yield from self._ingest_json_array(path)
+
+    def _ingest_ndjson(self, path: Path) -> Iterator[RawLexeme]:
+        with path.open("rb") as fh:
+            for line_num, line in enumerate(fh, start=1):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    obj = orjson.loads(line)
+                except orjson.JSONDecodeError:
+                    logger.warning("Skipping invalid JSON at line %d", line_num)
+                    continue
+                lexeme = self._map_object(obj, line_num)
+                if lexeme:
+                    yield lexeme
+
+    def _ingest_json_array(self, path: Path) -> Iterator[RawLexeme]:
+        data = orjson.loads(path.read_bytes())
+        if isinstance(data, list):
+            items = data
+        elif isinstance(data, dict):
+            # Try to find a list field
+            for key in ("forms", "data", "entries", "items", "results"):
+                if key in data and isinstance(data[key], list):
+                    items = data[key]
+                    break
+            else:
+                items = [data]
+        else:
+            return
+
+        for idx, obj in enumerate(items, start=1):
+            lexeme = self._map_object(obj, idx)
+            if lexeme:
+                yield lexeme
+
+    def _map_object(self, obj: dict, idx: int) -> RawLexeme | None:
+        mapping = self.source_def.column_mapping
+        form = self._get_nested(obj, mapping.form) or ""
+        if not form or form == "_":
+            return None
+
+        language_id = self._get_nested(obj, mapping.language) or ""
+        concept_id = self._get_nested(obj, mapping.concept) or ""
+        glottocode = ""
+        if mapping.glottocode:
+            glottocode = self._get_nested(obj, mapping.glottocode) or ""
+        phonetic_raw = ""
+        transcription_type = TranscriptionType.UNKNOWN
+        if mapping.ipa:
+            phonetic_raw = self._get_nested(obj, mapping.ipa) or ""
+            if phonetic_raw:
+                transcription_type = TranscriptionType.IPA
+
+        return RawLexeme(
+            id=f"{self.source_def.name}_{idx}",
+            language_id=language_id,
+            glottocode=glottocode,
+            concept_id=concept_id,
+            form=form,
+            phonetic_raw=phonetic_raw,
+            transcription_type=transcription_type,
+            source_name=self.source_def.name,
+            provenance=ProvenanceRecord(
+                source_name=self.source_def.name,
+                source_format=self.source_def.format.value,
+                original_id=str(idx),
+            ).add_step("ingest", {"index": idx}),
+        )
+
+    @staticmethod
+    def _get_nested(obj: dict, path: str) -> str:
+        """Resolve a dot-separated path in a nested dict."""
+        if not path:
+            return ""
+        parts = path.split(".")
+        current = obj
+        for part in parts:
+            if isinstance(current, dict):
+                current = current.get(part)
+            else:
+                return ""
+            if current is None:
+                return ""
+        return str(current)

cognate_pipeline/src/cognate_pipeline/ingest/language_map.json

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

cognate_pipeline/src/cognate_pipeline/ingest/language_resolver.py

@@ -0,0 +1,75 @@
+"""Resolve language identifiers to Glottocodes."""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+from cognate_pipeline.utils.glottolog import GlottologTree
+
+logger = logging.getLogger(__name__)
+
+# Load language map from JSON (generated by scripts/convert_cldf_to_tsv.py).
+# Falls back to a minimal hardcoded map if the JSON is missing.
+_LANGUAGE_MAP_PATH = Path(__file__).parent / "language_map.json"
+
+_HARDCODED_FALLBACK: dict[str, str] = {
+    "uga": "ugar1238", "heb": "hebr1245", "got": "goth1244", "xib": "iber1250",
+    "akk": "akka1240", "sux": "sume1241", "lat": "lati1261", "grc": "anci1242",
+    "arc": "offi1241", "egy": "egyp1253", "hit": "hitt1242", "phn": "phoe1239",
+    "syc": "clas1252", "eus": "basq1248",
+    "ang": "olde1238", "non": "oldn1244", "goh": "oldh1241",
+    "sga": "oldi1245", "cym": "wels1247", "bre": "bret1244",
+    "lit": "lith1251", "chu": "chur1257", "rus": "russ1263",
+    "san": "sans1269", "ave": "aves1237", "fas": "west2369",
+    "osc": "osca1245", "xum": "umbr1253", "gmy": "myce1241",
+    "arb": "stan1318", "amh": "amha1245",
+    "otk": "oldt1247", "tur": "nucl1301", "aze": "nort2697",
+    "fin": "finn1318", "hun": "hung1274", "est": "esto1258",
+}
+
+if _LANGUAGE_MAP_PATH.exists():
+    with open(_LANGUAGE_MAP_PATH, encoding="utf-8") as _f:
+        _HARDCODED: dict[str, str] = json.load(_f)
+    logger.debug("Loaded %d language mappings from %s", len(_HARDCODED), _LANGUAGE_MAP_PATH)
+else:
+    _HARDCODED = _HARDCODED_FALLBACK
+    logger.debug("Using fallback language map (%d entries)", len(_HARDCODED))
+
+
+class LanguageResolver:
+    """Resolve language identifiers to Glottocodes.
+
+    Resolution chain:
+    1. Direct Glottocode (4-char alpha + 4-digit pattern)
+    2. Hardcoded ancient language mappings
+    3. Glottolog tree lookup (by code, ISO-639-3, or name)
+    """
+
+    def __init__(self, glottolog_tree: GlottologTree | None = None) -> None:
+        self._tree = glottolog_tree
+
+    def resolve(self, identifier: str) -> str:
+        """Return a Glottocode for the given identifier, or '' if unresolved."""
+        identifier = identifier.strip()
+        if not identifier:
+            return ""
+
+        # Check if it's already a Glottocode pattern (xxxx1234)
+        if len(identifier) == 8 and identifier[:4].isalpha() and identifier[4:].isdigit():
+            return identifier
+
+        # Hardcoded mappings
+        if identifier.lower() in _HARDCODED:
+            return _HARDCODED[identifier.lower()]
+
+        # Glottolog tree lookup
+        if self._tree is not None:
+            lang = self._tree.lookup(identifier)
+            if lang is not None:
+                return lang.glottocode
+
+        logger.debug("Could not resolve language identifier: %s", identifier)
+        return ""

cognate_pipeline/src/cognate_pipeline/ingest/models.py

@@ -0,0 +1,123 @@
+"""Data models for the ingestion layer."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from cognate_pipeline.provenance.tracker import ProvenanceRecord
+
+
+class TranscriptionType:
+    """Constants for the type of phonetic representation stored."""
+
+    IPA = "ipa"                          # True IPA transcription
+    TRANSLITERATION = "transliteration"  # Script transliteration (e.g. Ugaritic consonantal)
+    ORTHOGRAPHIC = "orthographic"        # Standard orthography (e.g. Gothic Latin letters)
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class RawLexeme:
+    """A single lexical form as ingested from a source."""
+
+    id: str
+    language_id: str
+    glottocode: str
+    concept_id: str
+    form: str
+    phonetic_raw: str = ""
+    transcription_type: str = TranscriptionType.UNKNOWN
+    alternatives: list[str] = field(default_factory=list)
+    source_name: str = ""
+    provenance: ProvenanceRecord | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    # Backward-compatible alias
+    @property
+    def ipa_raw(self) -> str:
+        return self.phonetic_raw
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "language_id": self.language_id,
+            "glottocode": self.glottocode,
+            "concept_id": self.concept_id,
+            "form": self.form,
+            "phonetic_raw": self.phonetic_raw,
+            "transcription_type": self.transcription_type,
+            "alternatives": self.alternatives,
+            "source_name": self.source_name,
+            "provenance": self.provenance.to_dict() if self.provenance else None,
+            "extra": self.extra,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> RawLexeme:
+        prov = d.get("provenance")
+        return cls(
+            id=d["id"],
+            language_id=d["language_id"],
+            glottocode=d.get("glottocode", ""),
+            concept_id=d.get("concept_id", ""),
+            form=d["form"],
+            phonetic_raw=d.get("phonetic_raw", d.get("ipa_raw", "")),
+            transcription_type=d.get("transcription_type", TranscriptionType.UNKNOWN),
+            alternatives=d.get("alternatives", []),
+            source_name=d.get("source_name", ""),
+            provenance=ProvenanceRecord.from_dict(prov) if prov else None,
+            extra=d.get("extra", {}),
+        )
+
+
+@dataclass
+class RawNameForm:
+    """A named entity form (place name, personal name, etc.)."""
+
+    id: str
+    entity_type: str
+    language_id: str
+    glottocode: str
+    name_string: str
+    ipa_raw: str = ""
+    source_name: str = ""
+    external_ids: dict[str, str] = field(default_factory=dict)
+    latitude: float | None = None
+    longitude: float | None = None
+    provenance: ProvenanceRecord | None = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "entity_type": self.entity_type,
+            "language_id": self.language_id,
+            "glottocode": self.glottocode,
+            "name_string": self.name_string,
+            "ipa_raw": self.ipa_raw,
+            "source_name": self.source_name,
+            "external_ids": self.external_ids,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "provenance": self.provenance.to_dict() if self.provenance else None,
+            "extra": self.extra,
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict[str, Any]) -> RawNameForm:
+        prov = d.get("provenance")
+        return cls(
+            id=d["id"],
+            entity_type=d["entity_type"],
+            language_id=d["language_id"],
+            glottocode=d.get("glottocode", ""),
+            name_string=d["name_string"],
+            ipa_raw=d.get("ipa_raw", ""),
+            source_name=d.get("source_name", ""),
+            external_ids=d.get("external_ids", {}),
+            latitude=d.get("latitude"),
+            longitude=d.get("longitude"),
+            provenance=ProvenanceRecord.from_dict(prov) if prov else None,
+            extra=d.get("extra", {}),
+        )

cognate_pipeline/src/cognate_pipeline/ingest/wiktionary_ingester.py

@@ -0,0 +1,94 @@
+"""Wiktextract JSONL ingester."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterator
+from pathlib import Path
+
+import orjson
+
+from cognate_pipeline.config.schema import SourceDef
+from cognate_pipeline.ingest.models import RawLexeme, TranscriptionType
+from cognate_pipeline.provenance.tracker import ProvenanceRecord
+
+logger = logging.getLogger(__name__)
+
+
+class WiktionaryIngester:
+    """Ingests Wiktextract JSONL exports.
+
+    Each line is a JSON object with at minimum:
+      - word: the headword
+      - lang: language name
+      - lang_code: Wiktionary language code
+      - pronunciations: list of {ipa: "...", ...}
+      - senses: list of {glosses: [...], ...}
+    """
+
+    def __init__(self, source_def: SourceDef) -> None:
+        self.source_def = source_def
+
+    def ingest(self) -> Iterator[RawLexeme]:
+        path = Path(self.source_def.path)
+        with path.open("rb") as fh:
+            for line_num, line in enumerate(fh, start=1):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = orjson.loads(line)
+                except orjson.JSONDecodeError:
+                    logger.warning("Skipping invalid JSON at line %d", line_num)
+                    continue
+
+                word = entry.get("word", "").strip()
+                if not word:
+                    continue
+
+                lang = entry.get("lang", "")
+                lang_code = entry.get("lang_code", "")
+
+                # Extract IPA from pronunciations (Wiktionary provides true IPA)
+                phonetic_raw = ""
+                transcription_type = TranscriptionType.ORTHOGRAPHIC
+                pronunciations = entry.get("pronunciations", entry.get("sounds", []))
+                if isinstance(pronunciations, list):
+                    for pron in pronunciations:
+                        if isinstance(pron, dict) and pron.get("ipa"):
+                            phonetic_raw = pron["ipa"]
+                            transcription_type = TranscriptionType.IPA
+                            break
+
+                # Extract concept from first sense gloss
+                concept_id = ""
+                senses = entry.get("senses", [])
+                if senses and isinstance(senses, list):
+                    first_sense = senses[0]
+                    if isinstance(first_sense, dict):
+                        glosses = first_sense.get("glosses", [])
+                        if glosses:
+                            concept_id = glosses[0]
+
+                # Extract etymology info
+                etymology = entry.get("etymology_text", "")
+
+                yield RawLexeme(
+                    id=f"{self.source_def.name}_{line_num}",
+                    language_id=lang_code or lang,
+                    glottocode="",
+                    concept_id=concept_id,
+                    form=word,
+                    phonetic_raw=phonetic_raw,
+                    transcription_type=transcription_type,
+                    source_name=self.source_def.name,
+                    provenance=ProvenanceRecord(
+                        source_name=self.source_def.name,
+                        source_format="wiktionary",
+                        original_id=f"line_{line_num}",
+                    ).add_step(
+                        "ingest",
+                        {"file": path.name, "line": line_num},
+                    ),
+                    extra={"etymology": etymology} if etymology else {},
+                )

cognate_pipeline/src/cognate_pipeline/normalise/epitran_backend.py

@@ -0,0 +1,62 @@
+"""Epitran wrapper for grapheme-to-phoneme conversion."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+# Cache of Epitran instances by language code
+_EPITRAN_CACHE: dict[str, Any] = {}
+
+# Mapping from Glottocode/ISO to Epitran language codes
+_LANG_TO_EPITRAN: dict[str, str] = {
+    "eng": "eng-Latn",
+    "deu": "deu-Latn",
+    "fra": "fra-Latn",
+    "spa": "spa-Latn",
+    "ita": "ita-Latn",
+    "por": "por-Latn",
+    "tur": "tur-Latn",
+    "ara": "ara-Arab",
+    "hin": "hin-Deva",
+    "rus": "rus-Cyrl",
+}
+
+
+def _get_epitran(lang_code: str) -> Any | None:
+    """Get or create an Epitran instance for the given language code."""
+    if lang_code in _EPITRAN_CACHE:
+        return _EPITRAN_CACHE[lang_code]
+
+    try:
+        import epitran
+    except ImportError:
+        logger.debug("epitran not installed")
+        return None
+
+    # Resolve to Epitran-format code
+    epitran_code = _LANG_TO_EPITRAN.get(lang_code, lang_code)
+    try:
+        epi = epitran.Epitran(epitran_code)
+        _EPITRAN_CACHE[lang_code] = epi
+        return epi
+    except Exception as exc:
+        logger.debug("Epitran failed for %s: %s", epitran_code, exc)
+        return None
+
+
+def transliterate(text: str, lang_code: str) -> str | None:
+    """Convert orthographic text to IPA using Epitran.
+
+    Returns None if Epitran is unavailable or the language is unsupported.
+    """
+    epi = _get_epitran(lang_code)
+    if epi is None:
+        return None
+    try:
+        return epi.transliterate(text)
+    except Exception as exc:
+        logger.warning("Epitran transliteration failed for '%s' (%s): %s", text, lang_code, exc)
+        return None