Add scripture detector app

Initial implementation with screenshots tracked via Git LFS.

Made-with: Cursor

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,183 @@
+*.db
+.env
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor  
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to 
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

Dockerfile

@@ -0,0 +1,50 @@
+# ── Scripture Detector ────────────────────────────────────────────────────────
+#
+# Build:
+#   docker build -t scripture-detector .
+#
+# Run (ephemeral in-memory database — data resets on container restart):
+#   docker run -p 5001:5001 scripture-detector
+#
+# Run (persistent database — mount a host directory):
+#   docker run -p 5001:5001 \
+#     -v "$(pwd)/data_volume:/app/db" \
+#     -e SD_DB_DIR=/app/db \
+#     -e GEMINI_API_KEY=your_key_here \
+#     scripture-detector python app.py
+#
+# The default CMD uses --cache-db (in-memory SQLite) which is ideal for
+# workshops and demos where persistence across restarts is not needed.
+# ─────────────────────────────────────────────────────────────────────────────
+
+FROM python:3.12-slim
+
+# Install uv (fast Python package manager)
+RUN pip install --no-cache-dir uv
+
+WORKDIR /app
+
+# Clone the scripture-detector repository and change directory into it
+RUN git clone https://github.com/yale-ch/scripture-detector.git /app && cd /app
+
+
+# Copy dependency manifest first to leverage Docker layer caching.
+# Dependencies are only re-installed when pyproject.toml / uv.lock changes.
+COPY pyproject.toml uv.lock* ./
+
+# Sync dependencies (no dev extras)
+RUN uv sync --no-dev --frozen || uv sync --no-dev
+
+# Copy application source
+COPY . .
+
+# Bind to all interfaces inside the container
+ENV SD_HOST=0.0.0.0
+ENV SD_PORT=5432
+
+# Expose the Flask port
+EXPOSE 5432
+
+# Default: run with --cache-db (in-memory database, no volume needed).
+# To use a persistent database instead, override CMD and set SD_DB_DIR.
+CMD ["uv", "run", "python", "app.py", "--cache-db"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 William Mattingly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README copy.md

@@ -0,0 +1,180 @@
+# Scripture Detector
+
+> **AI-powered detection and analysis of biblical quotations, paraphrases, and allusions in historical texts.**
+
+![Sources page](static/screenshots/sources.png)
+
+Developed by **Dr. William J.B. Mattingly**, Cultural Heritage Data Scientist at Yale University.
+
+Built for the international workshop **[Ruse of Reuse: Detecting Text-similarity with AI in Historical Sources](https://www.oeaw.ac.at/en/imafo/events/event-details/ruse-of-reuse)** — held **March 5–6, 2026** at the Austrian Academy of Sciences, Vienna.
+
+---
+
+## Overview
+
+Scripture Detector is a local web application that uses Google Gemini to automatically find, classify, and annotate every biblical reference in any text you provide — from full verbatim quotations to subtle allusions. It renders an interactive, color-coded view of the source text with side-by-side Bible verse lookup, distribution charts, and a manual annotation editor.
+
+**The only external dependency is a free Gemini API key** from [Google AI Studio](https://aistudio.google.com/apikey). No cloud account, credit card, or additional infrastructure is required.
+
+---
+
+## Screenshots
+
+### Sources Page — with Advanced Search
+Manage all your text sources. Use the search bar to search source content in real time, or open the **Advanced** panel to stack filters by Bible book, chapter, or verse with AND / OR logic. Match evidence appears directly on each result card.
+
+![Sources page](static/screenshots/sources.png)
+
+### Text Viewer
+Color-coded annotations appear directly in the text. Click any highlighted passage to see the matched Bible verse(s) in the panel on the right.
+
+![Viewer page](static/screenshots/viewer.png)
+
+### Analytics Dashboard
+Explore scripture distribution across all sources — broken down by Bible book, testament, and quote type.
+
+![Dashboard](static/screenshots/dashboard.png)
+
+### Settings
+Configure your Gemini API key or Google Vertex AI credentials, and select which Gemini model to use.
+
+![Settings page](static/screenshots/settings.png)
+
+### About Page
+Full documentation of the application, its features, and how it works.
+
+![About page](static/screenshots/about.png)
+
+---
+
+## Features
+
+- **Full-document AI analysis** — send any text to Gemini and receive a structured list of every scripture reference with verse citations and classification types.
+- **Four classification types**: Full, Partial, Paraphrase, and Allusion.
+- **Color-coded in-text highlighting** — each type is rendered in a distinct color directly within the source text.
+- **Click-to-explore interactivity** — click a highlighted passage to highlight the corresponding annotation card, and vice versa.
+- **Selection-based re-analysis** — highlight any portion of the text to re-run AI detection on just that selection.
+- **Manual annotation editor** with an integrated Bible verse picker (book → chapter → verse).
+- **Advanced search** — real-time multi-filter search across all sources by text content, Bible book, chapter, or verse; filters stack with AND / OR logic and matched evidence appears inline on each result card.
+- **Distribution charts** per source and across all sources (by Bible book, testament, and type).
+- **Global analytics dashboard** aggregating data across all sources.
+- **Model switching** — choose between available Gemini model versions in the UI.
+- **Runs entirely locally** — your texts are never transmitted anywhere except for the Gemini API call itself.
+
+---
+
+## Advanced Search
+
+The Sources page includes a real-time multi-filter search system:
+
+| Filter Type | What it matches |
+|---|---|
+| **Text Content** | Any source whose full text contains the search string |
+| **Bible Book** | Any source with at least one reference to the chosen book |
+| **Chapter** | Any source with a reference to the chosen chapter (e.g. Psalms 23) |
+| **Verse** | Any source with a reference to the exact chosen verse (e.g. John 3:16) |
+
+Filters can be stacked in any combination. The **AND** mode requires a source to satisfy *every* filter; **OR** mode returns sources satisfying *any* filter. Results update within ~350 ms of each keystroke or dropdown change. Matched text snippets and verse citations appear as inline evidence on each result card.
+
+---
+
+## Quick Start
+
+### 1. Prerequisites
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/) (recommended) or pip
+- A free **Gemini API key** from [Google AI Studio](https://aistudio.google.com/apikey)
+
+### 2. Install & Run
+
+```bash
+git clone <repo-url>
+cd scripture-detector
+
+# Using uv (recommended)
+uv run python app.py
+
+# Or using pip
+pip install -e .
+python app.py
+```
+
+The app starts at **http://127.0.0.1:5001**.
+
+### 3. Configure API Key
+
+1. Open [http://127.0.0.1:5001/settings](http://127.0.0.1:5001/settings)
+2. Select **Gemini API** as the provider
+3. Paste your API key from [Google AI Studio](https://aistudio.google.com/apikey)
+4. Click **Save Settings**
+
+### 4. Analyze a Text
+
+1. Go to the **Sources** page and click **Add Source**
+2. Give your source a name and paste in the text to analyze
+3. Click **View** to open the text viewer
+4. Click **Process with AI** — Gemini will detect all scripture references within seconds
+5. Click any highlighted passage to explore the matched Bible verses
+
+---
+
+## Quote Classification
+
+| Type | Description |
+|---|---|
+| **Full** | A complete or near-complete verse quoted verbatim |
+| **Partial** | A recognizable portion of a verse with minor variation or truncation |
+| **Paraphrase** | Biblical content restated in different words, preserving the meaning |
+| **Allusion** | A brief phrase, thematic echo, or indirect reference to a specific verse |
+
+---
+
+## Project Structure
+
+```
+scripture-detector/
+├── app.py              # Flask application and API routes
+├── database.py         # SQLite database layer
+├── main.py             # CLI batch evaluation script
+├── data/
+│   ├── bible.tsv       # Full Bible verse database (35,000+ verses)
+│   └── book_mapping.tsv
+├── templates/
+│   ├── sources.html    # Sources listing page
+│   ├── viewer.html     # Annotated text viewer
+│   ├── dashboard.html  # Global analytics dashboard
+│   ├── settings.html   # API configuration
+│   └── about.html      # About / documentation page
+└── static/
+    ├── style.css        # Yale color palette stylesheet
+    ├── logo.svg         # Application logo
+    └── favicon.svg      # Browser tab icon
+```
+
+---
+
+## API Providers
+
+### Gemini API (Free Tier)
+The simplest option. Get a free key at [Google AI Studio](https://aistudio.google.com/apikey) — no billing required. Select **Gemini API** in Settings and paste your key.
+
+### Google Vertex AI
+For enterprise use or higher rate limits. Requires a Google Cloud project with Vertex AI enabled. Select **Vertex AI** in Settings and enter your project ID and location.
+
+---
+
+## About
+
+**Developer:** Dr. William J.B. Mattingly  
+**Affiliation:** Yale University, Cultural Heritage Data Scientist  
+**Workshop:** [Ruse of Reuse: Detecting Text-similarity with AI in Historical Sources](https://www.oeaw.ac.at/en/imafo/events/event-details/ruse-of-reuse)  
+**Workshop Dates:** March 5–6, 2026  
+**Workshop Venue:** Austrian Academy of Sciences, PSK Georg-Coch-Platz 2, 1010 Vienna  
+**Organisers:** Digital Lab, Institute for Medieval Research, Austrian Academy of Sciences & [SOLEMNE](https://canones.org/), Radboud University  
+
+---
+
+## License
+
+MIT

app.py

@@ -0,0 +1,728 @@
+import os
+import sys
+
+# ── parse custom flags BEFORE importing database (which reads env vars) ───────
+_argv = sys.argv[1:]
+if "--cache-db" in _argv:
+    os.environ["SCRIPTURE_DETECTOR_CACHE_DB"] = "1"
+# Remove our custom flags so Flask/werkzeug doesn't choke on them
+sys.argv = [sys.argv[0]] + [a for a in _argv if a != "--cache-db"]
+
+import csv
+import io
+import json
+import re
+import zipfile
+from datetime import date
+from pathlib import Path
+
+from flask import Flask, render_template, jsonify, request, redirect, url_for, Response
+from google import genai
+
+from database import (
+    init_db,
+    create_source, get_source, get_all_sources, delete_source,
+    add_quote, update_quote, delete_quote, get_quotes_for_source,
+    delete_quotes_for_source, delete_quotes_in_range,
+    get_setting, set_setting, get_all_settings,
+    get_book_distribution, get_quote_type_distribution, get_dashboard_data,
+    search_sources,
+)
+from tei import source_to_tei, tei_to_source_data
+
+app = Flask(__name__)
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+BIBLE_TSV_PATH = PROJECT_ROOT / "data" / "bible.tsv"
+BOOK_MAPPING_PATH = PROJECT_ROOT / "data" / "book_mapping.tsv"
+
+MODELS = [
+    {"id": "gemini-3-pro-preview", "name": "Gemini 3 Pro Preview"},
+    {"id": "gemini-3-flash-preview", "name": "Gemini 3 Flash Preview"},
+    {"id": "gemini-3.1-pro-preview", "name": "Gemini 3.1 Pro Preview"},
+    {"id": "gemini-3.1-flash-lite-preview", "name": "Gemini 3.1 Flash Lite Preview"},
+]
+
+_bible_cache: dict[str, str] | None = None
+_book_mapping_cache: dict[str, dict] | None = None
+_bible_structure_cache: dict[str, dict[int, list[dict]]] | None = None
+
+
+def bible_verses() -> dict[str, str]:
+    global _bible_cache
+    if _bible_cache is not None:
+        return _bible_cache
+    verses: dict[str, str] = {}
+    with open(BIBLE_TSV_PATH, newline="", encoding="utf-8") as f:
+        for row in csv.DictReader(f, delimiter="\t"):
+            book = row["book_code"].strip().lower()
+            chapter = str(int(row["chapter_number"]))
+            verse = str(int(row["verse_index"]))
+            verses[f"{book}_{chapter}:{verse}"] = row["text"]
+    _bible_cache = verses
+    return verses
+
+
+def book_mapping() -> dict[str, dict]:
+    global _book_mapping_cache
+    if _book_mapping_cache is not None:
+        return _book_mapping_cache
+    mapping: dict[str, dict] = {}
+    with open(BOOK_MAPPING_PATH, newline="", encoding="utf-8") as f:
+        for row in csv.DictReader(f, delimiter="\t"):
+            code = row["book_code"].strip().lower()
+            mapping[code] = {"name": row["work_name"], "testament": row["testament"]}
+    _book_mapping_cache = mapping
+    return mapping
+
+
+def bible_structure() -> dict[str, dict[int, list[dict]]]:
+    global _bible_structure_cache
+    if _bible_structure_cache is not None:
+        return _bible_structure_cache
+    structure: dict[str, dict[int, list[dict]]] = {}
+    with open(BIBLE_TSV_PATH, newline="", encoding="utf-8") as f:
+        for row in csv.DictReader(f, delimiter="\t"):
+            book = row["book_code"].strip().lower()
+            chapter = int(row["chapter_number"])
+            verse = int(row["verse_index"])
+            text = row["text"]
+            if book not in structure:
+                structure[book] = {}
+            if chapter not in structure[book]:
+                structure[book][chapter] = []
+            structure[book][chapter].append({"verse": verse, "text": text})
+    for book in structure:
+        for chapter in structure[book]:
+            structure[book][chapter].sort(key=lambda v: v["verse"])
+    _bible_structure_cache = structure
+    return structure
+
+
+def get_valid_book_codes() -> list[str]:
+    return sorted(book_mapping().keys())
+
+
+# ── AI Integration ───────────────────────────────────────────────────────────
+
+def get_genai_client():
+    settings = get_all_settings()
+    provider = settings.get("api_provider", "gemini")
+    if provider == "vertex":
+        project_id = settings.get("vertex_project_id", "")
+        location = settings.get("vertex_location", "global")
+        if not project_id:
+            raise ValueError("Vertex AI Project ID not configured. Go to Settings.")
+        return genai.Client(vertexai=True, project=project_id, location=location)
+    else:
+        api_key = settings.get("gemini_api_key", "")
+        if not api_key:
+            raise ValueError("Gemini API Key not configured. Go to Settings.")
+        return genai.Client(api_key=api_key)
+
+
+def get_model() -> str:
+    return get_setting("model", "gemini-3-pro-preview")
+
+
+def build_prompt(text: str) -> str:
+    codes_str = ", ".join(get_valid_book_codes())
+    bm = book_mapping()
+    mapping_lines = "\n".join(f"  {v['name']} -> {k}" for k, v in sorted(bm.items()))
+    return f"""You are an expert in biblical texts and scripture detection.
+
+Given the following text, identify ALL scriptural (Biblical) quotations, partial quotations, paraphrases, and clear allusions to specific Bible verses.
+
+For each identified passage:
+1. Extract the EXACT text as it appears in the document — preserve the original spelling, punctuation, and word order verbatim.
+2. Identify the specific Bible verse(s) being quoted or referenced.
+3. Classify the type of reuse as one of:
+   - "full"       — a complete or near-complete verse quoted verbatim.
+   - "partial"    — a recognisable portion of a verse, quoted with minor variation or truncation.
+   - "paraphrase" — the biblical content is clearly restated in different words while preserving the meaning.
+   - "allusion"   — a brief phrase, thematic echo, or indirect reference to a specific verse.
+
+Reference format: book_chapter:verse  (e.g. matt_5:9, ps_82:14, 1cor_15:33)
+CRITICAL: Each reference must be a SINGLE verse. Never use ranges like matt_15:1-2.
+Instead, list each verse separately: matt_15:1, matt_15:2.
+
+Valid book codes: {codes_str}
+
+Book name to code mapping:
+{mapping_lines}
+
+Important:
+- Include both direct quotes and partial quotes / paraphrases / allusions.
+- A single passage may reference multiple Bible verses — list all of them.
+- Be thorough — identify even brief allusions to specific verses.
+- The extracted text must be a verbatim substring of the input document.
+
+TEXT:
+{text}"""
+
+
+_RANGE_RE = re.compile(r"^(.+_\d+):(\d+)-(\d+)$")
+
+
+def expand_range_references(refs: list[str]) -> list[str]:
+    expanded: list[str] = []
+    for ref in refs:
+        m = _RANGE_RE.match(ref.strip())
+        if m:
+            prefix, start, end = m.group(1), int(m.group(2)), int(m.group(3))
+            for v in range(start, end + 1):
+                expanded.append(f"{prefix}:{v}")
+        else:
+            expanded.append(ref.strip())
+    return expanded
+
+
+def extract_quotes_with_gemini(text: str) -> list[dict]:
+    client = get_genai_client()
+    model = get_model()
+    prompt = build_prompt(text)
+
+    response_schema = {
+        "type": "ARRAY",
+        "items": {
+            "type": "OBJECT",
+            "properties": {
+                "text": {
+                    "type": "STRING",
+                    "description": "The exact text of the scriptural quote as it appears verbatim in the document",
+                },
+                "resolved_references": {
+                    "type": "ARRAY",
+                    "items": {"type": "STRING"},
+                    "description": "List of Bible verse references in format book_chapter:verse",
+                },
+                "quote_type": {
+                    "type": "STRING",
+                    "enum": ["full", "partial", "paraphrase", "allusion"],
+                    "description": "Type of biblical reuse",
+                },
+            },
+            "required": ["text", "resolved_references", "quote_type"],
+        },
+    }
+
+    response = client.models.generate_content(
+        model=model,
+        contents=prompt,
+        config={
+            "response_mime_type": "application/json",
+            "response_schema": response_schema,
+        },
+    )
+
+    quotes = json.loads(response.text)
+    for q in quotes:
+        q["resolved_references"] = expand_range_references(q.get("resolved_references", []))
+    return quotes
+
+
+def find_spans(text: str, quotes: list[dict]) -> list[dict]:
+    results = []
+    for quote in quotes:
+        qt = quote["text"]
+        idx = text.find(qt)
+        if idx == -1:
+            idx = text.lower().find(qt.lower())
+        span_start = idx if idx != -1 else None
+        span_end = (idx + len(qt)) if idx != -1 else None
+        results.append({
+            "text": qt,
+            "span_start": span_start,
+            "span_end": span_end,
+            "resolved_references": quote["resolved_references"],
+            "quote_type": quote.get("quote_type", "allusion"),
+        })
+    return results
+
+
+def compute_segments(text: str, annotations: list[dict]) -> list[dict]:
+    boundaries: set[int] = {0, len(text)}
+    for a in annotations:
+        if a["span_start"] is not None:
+            boundaries.add(a["span_start"])
+            boundaries.add(a["span_end"])
+    ordered = sorted(boundaries)
+
+    segments = []
+    for i in range(len(ordered) - 1):
+        start, end = ordered[i], ordered[i + 1]
+        ann_ids = [
+            j for j, a in enumerate(annotations)
+            if a["span_start"] is not None
+            and a["span_start"] <= start and end <= a["span_end"]
+        ]
+        segments.append({
+            "text": text[start:end],
+            "start": start,
+            "end": end,
+            "annotation_ids": ann_ids,
+        })
+    return segments
+
+
+# ── Page Routes ──────────────────────────────────────────────────────────────
+
+@app.route("/")
+def sources_page():
+    return render_template("sources.html")
+
+
+@app.route("/dashboard")
+def dashboard():
+    return render_template("dashboard.html")
+
+
+@app.route("/viewer/<int:source_id>")
+def viewer(source_id: int):
+    source = get_source(source_id)
+    if not source:
+        return redirect(url_for("sources_page"))
+    settings = get_all_settings()
+    current_model = settings.get("model", "gemini-3-pro-preview")
+    return render_template("viewer.html", source=source, models=MODELS, current_model=current_model)
+
+
+@app.route("/settings")
+def settings_page():
+    return render_template("settings.html", models=MODELS)
+
+
+@app.route("/about")
+def about_page():
+    return render_template("about.html")
+
+
+# ── API: Search ───────────────────────────────────────────────────────────────
+
+@app.route("/api/search", methods=["POST"])
+def api_search():
+    body    = request.get_json() or {}
+    filters = body.get("filters", [])
+    logic   = body.get("logic", "AND")
+    if logic not in ("AND", "OR"):
+        logic = "AND"
+
+    # Normalise filter values to lowercase; reject empties
+    clean = [
+        {"type": f.get("type", "text"), "value": str(f.get("value", "")).strip().lower()}
+        for f in filters
+        if str(f.get("value", "")).strip()
+    ]
+
+    result = search_sources(clean, logic)
+
+    # Enrich book_distribution entries with human-readable names
+    bm = book_mapping()
+    for src in result["results"]:
+        for item in src.get("book_distribution", []):
+            info = bm.get(item["book_code"], {})
+            item["book_name"]  = info.get("name",      item["book_code"])
+            item["testament"]  = info.get("testament", "")
+
+    return jsonify(result)
+
+
+# ── API: Sources ─────────────────────────────────────────────────────────────
+
+@app.route("/api/sources", methods=["POST"])
+def api_create_source():
+    body = request.get_json()
+    name = body.get("name", "").strip()
+    text = body.get("text", "").strip()
+    if not name or not text:
+        return jsonify({"error": "Name and text are required"}), 400
+    source_id = create_source(name, text)
+    return jsonify({"id": source_id, "name": name})
+
+
+@app.route("/api/sources/<int:source_id>", methods=["GET"])
+def api_get_source(source_id: int):
+    source = get_source(source_id)
+    if not source:
+        return jsonify({"error": "Source not found"}), 404
+
+    quotes = get_quotes_for_source(source_id)
+    verses = bible_verses()
+    bm = book_mapping()
+
+    annotations = []
+    for q in quotes:
+        refs = [r["reference"] for r in q["references"]]
+        verse_lookup = []
+        for ref in refs:
+            ref_lower = ref.strip().lower()
+            book_code = ref_lower.split("_")[0] if "_" in ref_lower else ""
+            verse_lookup.append({
+                "ref": ref_lower,
+                "text": verses.get(ref_lower, ""),
+                "book_name": bm.get(book_code, {}).get("name", ""),
+            })
+        annotations.append({
+            "id": q["id"],
+            "span_start": q["span_start"],
+            "span_end": q["span_end"],
+            "quote_text": q["quote_text"],
+            "quote_type": q["quote_type"],
+            "refs": refs,
+            "verses": verse_lookup,
+        })
+
+    segments = compute_segments(source["text"], annotations)
+
+    return jsonify({
+        "source": {"id": source["id"], "name": source["name"]},
+        "segments": segments,
+        "annotations": annotations,
+    })
+
+
+@app.route("/api/sources/<int:source_id>", methods=["DELETE"])
+def api_delete_source(source_id: int):
+    delete_source(source_id)
+    return jsonify({"status": "ok"})
+
+
+# ── API: TEI Export (single source) ──────────────────────────────────────────
+
+@app.route("/api/sources/<int:source_id>/export/tei")
+def api_export_tei(source_id: int):
+    source = get_source(source_id)
+    if not source:
+        return jsonify({"error": "Source not found"}), 404
+
+    quotes      = get_quotes_for_source(source_id)
+    bm          = book_mapping()
+    book_names  = {code: info["name"] for code, info in bm.items()}
+    verses      = bible_verses()
+
+    annotations = []
+    for q in quotes:
+        refs = [r["reference"] for r in q["references"]]
+        annotations.append({
+            "id":          q["id"],
+            "span_start":  q["span_start"],
+            "span_end":    q["span_end"],
+            "quote_text":  q["quote_text"],
+            "quote_type":  q["quote_type"],
+            "refs":        refs,
+        })
+
+    xml_bytes = source_to_tei(source, annotations, book_names)
+    safe_name = re.sub(r"[^\w\-]", "_", source["name"])[:60]
+    filename  = f"{safe_name}.tei.xml"
+
+    return Response(
+        xml_bytes,
+        mimetype="application/xml",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
+# ── API: ZIP Export (all sources) ────────────────────────────────────────────
+
+@app.route("/api/export/zip")
+def api_export_zip():
+    sources    = get_all_sources()
+    bm         = book_mapping()
+    book_names = {code: info["name"] for code, info in bm.items()}
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        manifest = {
+            "version":      "1.0",
+            "app":          "Scripture Detector",
+            "exported":     date.today().isoformat(),
+            "source_count": len(sources),
+            "sources":      [],
+        }
+
+        for idx, src in enumerate(sources, start=1):
+            full_source = get_source(src["id"])
+            quotes      = get_quotes_for_source(src["id"])
+
+            annotations = []
+            for q in quotes:
+                annotations.append({
+                    "id":         q["id"],
+                    "span_start": q["span_start"],
+                    "span_end":   q["span_end"],
+                    "quote_text": q["quote_text"],
+                    "quote_type": q["quote_type"],
+                    "refs":       [r["reference"] for r in q["references"]],
+                })
+
+            xml_bytes = source_to_tei(full_source, annotations, book_names)
+            safe_name = re.sub(r"[^\w\-]", "_", src["name"])[:60]
+            fname = f"sources/{idx:04d}_{safe_name}.tei.xml"
+            zf.writestr(fname, xml_bytes)
+            manifest["sources"].append({"filename": fname, "name": src["name"]})
+
+        zf.writestr("manifest.json", json.dumps(manifest, indent=2, ensure_ascii=False))
+
+    buf.seek(0)
+    today = date.today().strftime("%Y%m%d")
+    return Response(
+        buf.read(),
+        mimetype="application/zip",
+        headers={
+            "Content-Disposition":
+                f'attachment; filename="scripture_detector_export_{today}.zip"'
+        },
+    )
+
+
+# ── API: ZIP Import ───────────────────────────────────────────────────────────
+
+@app.route("/api/import/zip", methods=["POST"])
+def api_import_zip():
+    if "file" not in request.files:
+        return jsonify({"error": "No file uploaded"}), 400
+
+    f = request.files["file"]
+    if not f.filename.lower().endswith(".zip"):
+        return jsonify({"error": "File must be a .zip archive"}), 400
+
+    imported = 0
+    errors   = []
+
+    try:
+        with zipfile.ZipFile(io.BytesIO(f.read()), "r") as zf:
+            # Collect TEI files (from sources/ sub-directory or root)
+            tei_names = sorted(
+                name for name in zf.namelist()
+                if name.lower().endswith(".tei.xml") or name.lower().endswith(".xml")
+            )
+
+            for name in tei_names:
+                try:
+                    xml_bytes   = zf.read(name)
+                    src_data    = tei_to_source_data(xml_bytes)
+                    source_id   = create_source(src_data["name"], src_data["text"])
+                    for ann in src_data["annotations"]:
+                        if ann.get("refs"):
+                            add_quote(
+                                source_id  = source_id,
+                                span_start = ann["span_start"],
+                                span_end   = ann["span_end"],
+                                quote_text = ann["quote_text"],
+                                quote_type = ann["quote_type"],
+                                references = ann["refs"],
+                            )
+                    imported += 1
+                except Exception as exc:
+                    errors.append({"file": name, "error": str(exc)})
+
+    except zipfile.BadZipFile:
+        return jsonify({"error": "Invalid or corrupt ZIP file"}), 400
+
+    return jsonify({
+        "status":   "ok",
+        "imported": imported,
+        "errors":   errors,
+    })
+
+
+# ── API: Processing ──────────────────────────────────────────────────────────
+
+@app.route("/api/sources/<int:source_id>/process", methods=["POST"])
+def api_process_source(source_id: int):
+    source = get_source(source_id)
+    if not source:
+        return jsonify({"error": "Source not found"}), 404
+    try:
+        quotes = extract_quotes_with_gemini(source["text"])
+        quotes_with_spans = find_spans(source["text"], quotes)
+        delete_quotes_for_source(source_id)
+        for q in quotes_with_spans:
+            add_quote(
+                source_id=source_id,
+                span_start=q["span_start"],
+                span_end=q["span_end"],
+                quote_text=q["text"],
+                quote_type=q["quote_type"],
+                references=q["resolved_references"],
+            )
+        return jsonify({"status": "ok", "count": len(quotes_with_spans)})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/sources/<int:source_id>/process-selection", methods=["POST"])
+def api_process_selection(source_id: int):
+    source = get_source(source_id)
+    if not source:
+        return jsonify({"error": "Source not found"}), 404
+    body = request.get_json()
+    start = body.get("start")
+    end = body.get("end")
+    if start is None or end is None:
+        return jsonify({"error": "start and end are required"}), 400
+
+    selection_text = source["text"][start:end]
+    if not selection_text.strip():
+        return jsonify({"error": "Empty selection"}), 400
+
+    try:
+        quotes = extract_quotes_with_gemini(selection_text)
+        quotes_with_spans = find_spans(selection_text, quotes)
+        delete_quotes_in_range(source_id, start, end)
+        count = 0
+        for q in quotes_with_spans:
+            adj_start = (q["span_start"] + start) if q["span_start"] is not None else None
+            adj_end = (q["span_end"] + start) if q["span_end"] is not None else None
+            add_quote(
+                source_id=source_id,
+                span_start=adj_start,
+                span_end=adj_end,
+                quote_text=q["text"],
+                quote_type=q["quote_type"],
+                references=q["resolved_references"],
+            )
+            count += 1
+        return jsonify({"status": "ok", "count": count})
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+# ── API: Quotes ──────────────────────────────────────────────────────────────
+
+@app.route("/api/quotes", methods=["POST"])
+def api_add_quote():
+    body = request.get_json()
+    source_id = body.get("source_id")
+    if not source_id:
+        return jsonify({"error": "source_id is required"}), 400
+    quote_id = add_quote(
+        source_id=source_id,
+        span_start=body.get("span_start"),
+        span_end=body.get("span_end"),
+        quote_text=body.get("quote_text", ""),
+        quote_type=body.get("quote_type", "allusion"),
+        references=body.get("references", []),
+    )
+    return jsonify({"id": quote_id})
+
+
+@app.route("/api/quotes/<int:quote_id>", methods=["PUT"])
+def api_update_quote(quote_id: int):
+    body = request.get_json()
+    update_quote(
+        quote_id=quote_id,
+        quote_text=body.get("quote_text"),
+        quote_type=body.get("quote_type"),
+        span_start=body.get("span_start"),
+        span_end=body.get("span_end"),
+        references=body.get("references"),
+    )
+    return jsonify({"status": "ok"})
+
+
+@app.route("/api/quotes/<int:quote_id>", methods=["DELETE"])
+def api_delete_quote(quote_id: int):
+    delete_quote(quote_id)
+    return jsonify({"status": "ok"})
+
+
+# ── API: Dashboard ───────────────────────────────────────────────────────────
+
+@app.route("/api/dashboard")
+def api_dashboard():
+    data = get_dashboard_data()
+    data["book_distribution"] = get_book_distribution()
+    data["type_distribution"] = get_quote_type_distribution()
+
+    bm = book_mapping()
+    for item in data["book_distribution"]:
+        info = bm.get(item["book_code"], {})
+        item["book_name"] = info.get("name", item["book_code"])
+        item["testament"] = info.get("testament", "")
+
+    for source in data["sources"]:
+        source["type_distribution"] = get_quote_type_distribution(source["id"])
+        source["book_distribution"] = get_book_distribution(source["id"])
+
+    return jsonify(data)
+
+
+@app.route("/api/sources/<int:source_id>/distribution")
+def api_source_distribution(source_id: int):
+    bm = book_mapping()
+    book_dist = get_book_distribution(source_id)
+    for item in book_dist:
+        info = bm.get(item["book_code"], {})
+        item["book_name"] = info.get("name", item["book_code"])
+        item["testament"] = info.get("testament", "")
+    type_dist = get_quote_type_distribution(source_id)
+    return jsonify({"book_distribution": book_dist, "type_distribution": type_dist})
+
+
+# ── API: Settings ────────────────────────────────────────────────────────────
+
+@app.route("/api/settings", methods=["GET"])
+def api_get_settings():
+    settings = get_all_settings()
+    if "gemini_api_key" in settings:
+        key = settings["gemini_api_key"]
+        settings["gemini_api_key_masked"] = (
+            key[:4] + "..." + key[-4:] if len(key) > 8 else "****"
+        )
+    return jsonify(settings)
+
+
+@app.route("/api/settings", methods=["POST"])
+def api_save_settings():
+    body = request.get_json()
+    for key, value in body.items():
+        if value is not None and str(value).strip() != "":
+            set_setting(key, str(value))
+    return jsonify({"status": "ok"})
+
+
+@app.route("/api/book-mapping")
+def api_book_mapping():
+    return jsonify(book_mapping())
+
+
+@app.route("/api/bible/books")
+def api_bible_books():
+    bm = book_mapping()
+    books = [
+        {"code": code, "name": info["name"], "testament": info["testament"]}
+        for code, info in sorted(bm.items(), key=lambda x: x[1]["name"])
+    ]
+    return jsonify(books)
+
+
+@app.route("/api/bible/<book_code>/chapters")
+def api_bible_chapters(book_code: str):
+    bs = bible_structure()
+    book = book_code.strip().lower()
+    if book not in bs:
+        return jsonify([])
+    return jsonify(sorted(bs[book].keys()))
+
+
+@app.route("/api/bible/<book_code>/<int:chapter>/verses")
+def api_bible_verses_list(book_code: str, chapter: int):
+    bs = bible_structure()
+    book = book_code.strip().lower()
+    if book not in bs or chapter not in bs[book]:
+        return jsonify([])
+    return jsonify(bs[book][chapter])
+
+
+init_db()
+
+if __name__ == "__main__":
+    _cache_db = bool(os.environ.get("SCRIPTURE_DETECTOR_CACHE_DB"))
+    _host  = os.environ.get("SD_HOST", "127.0.0.1")
+    _port  = int(os.environ.get("SD_PORT", "5001"))
+    # Disable the reloader in cache-db mode: the reloader forks the process,
+    # which would create a fresh in-memory database and lose all data.
+    _debug = not _cache_db
+    app.run(debug=_debug, port=_port, host=_host, use_reloader=_debug)

data/book_mapping.tsv

@@ -0,0 +1,74 @@
+testament	work_name	book_code
+ot	Genesis	gen
+ot	Exodus	exod
+ot	Leviticus	lev
+ot	Numeri	num
+ot	Deuteronomium	deut
+ot	Iosue	josh
+ot	Iudicum	judg
+ot	Ruth	ruth
+ot	I Samuelis	1sam
+ot	II Samuelis	2sam
+ot	I Regum	1kgs
+ot	II Regum	2kgs
+ot	I Paralipomenon	1chr
+ot	II Paralipomenon	2chr
+ot	Esdrae	ezra
+ot	Nehemiae	neh
+ap	Tobiae	tob
+ap	Iudith	jdt
+ot	Esther	esth
+ap	I Machabaeorum	1macc
+ap	II Machabaeorum	2macc
+ot	Iob	job
+ot	Psalmi	ps
+ot	Proverbia	prov
+ot	Ecclesiastes	eccl
+ot	Canticum Canticorum	song
+ap	Sapientia	wis
+ap	Ecclesiasticus	sir
+ot	Isaias	isa
+ot	Ieremias	jer
+ot	Lamentationes	lam
+ap	Baruch	bar
+ot	Ezechiel	ezek
+ot	Daniel	dan
+ot	Osee	hos
+ot	Ioel	joel
+ot	Amos	amos
+ot	Abdias	obad
+ot	Ionas	jonah
+ot	Michaeas	mic
+ot	Nahum	nah
+ot	Habacuc	hab
+ot	Sophonias	zeph
+ot	Aggaeus	hag
+ot	Zacharias	zech
+ot	Malachias	mal
+nt	Matthaeus	matt
+nt	Marcus	mark
+nt	Lucas	luke
+nt	Ioannes	john
+nt	Actus Apostolorum	acts
+nt	Romanos	rom
+nt	I Corinthios	1cor
+nt	II Corinthios	2cor
+nt	Galatas	gal
+nt	Ephesios	eph
+nt	Philippenses	phil
+nt	Colossenses	col
+nt	I Thessalonicenses	1thess
+nt	II Thessalonicenses	2thess
+nt	I Timotheum	1tim
+nt	II Timotheum	2tim
+nt	Titum	titus
+nt	Philemonem	phlm
+nt	Hebraeos	heb
+nt	Iacobi	jas
+nt	I Petri	1pet
+nt	II Petri	2pet
+nt	I Ioannis	1john
+nt	II Ioannis	2john
+nt	III Ioannis	3john
+nt	Iudae	jude
+nt	Apocalypsis	rev

database.py

@@ -0,0 +1,505 @@
+import os
+import sqlite3
+import re
+import threading
+from pathlib import Path
+from contextlib import contextmanager
+
+# SD_DB_DIR lets Docker users put the database in a mounted volume.
+_db_dir = os.environ.get("SD_DB_DIR")
+DB_PATH = (
+    Path(_db_dir) / "scripture_detector.db"
+    if _db_dir
+    else Path(__file__).resolve().parent / "scripture_detector.db"
+)
+
+# ── cache-db (in-memory) mode ─────────────────────────────────────────────────
+# Enabled by setting env var SCRIPTURE_DETECTOR_CACHE_DB=1 before this module
+# is imported.  app.py sets this when --cache-db flag is present.
+_CACHE_MODE: bool = os.environ.get("SCRIPTURE_DETECTOR_CACHE_DB", "") in ("1", "true", "yes")
+_cache_conn: sqlite3.Connection | None = None
+_cache_lock: threading.Lock = threading.Lock()
+
+
+def _make_cache_connection() -> sqlite3.Connection:
+    conn = sqlite3.connect(":memory:", check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    return conn
+
+
+def get_connection() -> sqlite3.Connection:
+    global _cache_conn
+    if _CACHE_MODE:
+        if _cache_conn is None:
+            _cache_conn = _make_cache_connection()
+        return _cache_conn
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    return conn
+
+
+@contextmanager
+def get_db():
+    if _CACHE_MODE:
+        # Serialise access to the single in-memory connection.
+        with _cache_lock:
+            conn = get_connection()
+            try:
+                yield conn
+                conn.commit()
+            except Exception:
+                conn.rollback()
+                raise
+    else:
+        conn = get_connection()
+        try:
+            yield conn
+            conn.commit()
+        except Exception:
+            conn.rollback()
+            raise
+        finally:
+            conn.close()
+
+
+def init_db():
+    with get_db() as conn:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS sources (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                text TEXT NOT NULL,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+            CREATE TABLE IF NOT EXISTS quotes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                source_id INTEGER NOT NULL,
+                span_start INTEGER,
+                span_end INTEGER,
+                quote_text TEXT NOT NULL,
+                quote_type TEXT NOT NULL DEFAULT 'allusion'
+                    CHECK(quote_type IN ('full','partial','paraphrase','allusion')),
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (source_id) REFERENCES sources(id) ON DELETE CASCADE
+            );
+            CREATE TABLE IF NOT EXISTS quote_references (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                quote_id INTEGER NOT NULL,
+                reference TEXT NOT NULL,
+                book_code TEXT,
+                FOREIGN KEY (quote_id) REFERENCES quotes(id) ON DELETE CASCADE
+            );
+            CREATE TABLE IF NOT EXISTS settings (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL
+            );
+        """)
+
+
+def extract_book_code(reference: str) -> str:
+    match = re.match(r"^([a-z0-9]+)_", reference.strip().lower())
+    return match.group(1) if match else ""
+
+
+# ── Sources ──────────────────────────────────────────────────────────────────
+
+def create_source(name: str, text: str) -> int:
+    with get_db() as conn:
+        cur = conn.execute(
+            "INSERT INTO sources (name, text) VALUES (?, ?)", (name, text)
+        )
+        return cur.lastrowid
+
+
+def get_source(source_id: int) -> dict | None:
+    with get_db() as conn:
+        row = conn.execute(
+            "SELECT * FROM sources WHERE id = ?", (source_id,)
+        ).fetchone()
+        return dict(row) if row else None
+
+
+def get_all_sources() -> list[dict]:
+    with get_db() as conn:
+        rows = conn.execute(
+            """SELECT s.id, s.name, s.created_at, s.updated_at,
+                      LENGTH(s.text) as text_length,
+                      COUNT(q.id) as quote_count
+               FROM sources s
+               LEFT JOIN quotes q ON q.source_id = s.id
+               GROUP BY s.id
+               ORDER BY s.created_at DESC"""
+        ).fetchall()
+        return [dict(r) for r in rows]
+
+
+def delete_source(source_id: int):
+    with get_db() as conn:
+        conn.execute("DELETE FROM sources WHERE id = ?", (source_id,))
+
+
+# ── Quotes ───────────────────────────────────────────────────────────────────
+
+def add_quote(
+    source_id: int,
+    span_start: int | None,
+    span_end: int | None,
+    quote_text: str,
+    quote_type: str,
+    references: list[str],
+) -> int:
+    with get_db() as conn:
+        cur = conn.execute(
+            """INSERT INTO quotes (source_id, span_start, span_end, quote_text, quote_type)
+               VALUES (?, ?, ?, ?, ?)""",
+            (source_id, span_start, span_end, quote_text, quote_type),
+        )
+        quote_id = cur.lastrowid
+        for ref in references:
+            ref_clean = ref.strip().lower()
+            book = extract_book_code(ref_clean)
+            conn.execute(
+                "INSERT INTO quote_references (quote_id, reference, book_code) VALUES (?, ?, ?)",
+                (quote_id, ref_clean, book),
+            )
+        return quote_id
+
+
+def update_quote(
+    quote_id: int,
+    quote_text: str = None,
+    quote_type: str = None,
+    span_start: int = None,
+    span_end: int = None,
+    references: list[str] = None,
+):
+    with get_db() as conn:
+        if quote_text is not None:
+            conn.execute(
+                "UPDATE quotes SET quote_text=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
+                (quote_text, quote_id),
+            )
+        if quote_type is not None:
+            conn.execute(
+                "UPDATE quotes SET quote_type=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
+                (quote_type, quote_id),
+            )
+        if span_start is not None:
+            conn.execute(
+                "UPDATE quotes SET span_start=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
+                (span_start, quote_id),
+            )
+        if span_end is not None:
+            conn.execute(
+                "UPDATE quotes SET span_end=?, updated_at=CURRENT_TIMESTAMP WHERE id=?",
+                (span_end, quote_id),
+            )
+        if references is not None:
+            conn.execute("DELETE FROM quote_references WHERE quote_id=?", (quote_id,))
+            for ref in references:
+                ref_clean = ref.strip().lower()
+                book = extract_book_code(ref_clean)
+                conn.execute(
+                    "INSERT INTO quote_references (quote_id, reference, book_code) VALUES (?, ?, ?)",
+                    (quote_id, ref_clean, book),
+                )
+
+
+def delete_quote(quote_id: int):
+    with get_db() as conn:
+        conn.execute("DELETE FROM quotes WHERE id = ?", (quote_id,))
+
+
+def get_quotes_for_source(source_id: int) -> list[dict]:
+    with get_db() as conn:
+        quotes = conn.execute(
+            "SELECT * FROM quotes WHERE source_id = ? ORDER BY span_start",
+            (source_id,),
+        ).fetchall()
+        result = []
+        for q in quotes:
+            qd = dict(q)
+            refs = conn.execute(
+                "SELECT reference, book_code FROM quote_references WHERE quote_id = ?",
+                (q["id"],),
+            ).fetchall()
+            qd["references"] = [dict(r) for r in refs]
+            result.append(qd)
+        return result
+
+
+def delete_quotes_for_source(source_id: int):
+    with get_db() as conn:
+        conn.execute("DELETE FROM quotes WHERE source_id = ?", (source_id,))
+
+
+def delete_quotes_in_range(source_id: int, start: int, end: int):
+    with get_db() as conn:
+        conn.execute(
+            """DELETE FROM quotes WHERE source_id = ?
+               AND span_start IS NOT NULL AND span_end IS NOT NULL
+               AND NOT (span_end <= ? OR span_start >= ?)""",
+            (source_id, start, end),
+        )
+
+
+# ── Settings ─────────────────────────────────────────────────────────────────
+
+def get_setting(key: str, default: str = None) -> str | None:
+    with get_db() as conn:
+        row = conn.execute("SELECT value FROM settings WHERE key=?", (key,)).fetchone()
+        return row["value"] if row else default
+
+
+def set_setting(key: str, value: str):
+    with get_db() as conn:
+        conn.execute(
+            "INSERT INTO settings (key, value) VALUES (?, ?) "
+            "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
+            (key, value),
+        )
+
+
+def get_all_settings() -> dict:
+    with get_db() as conn:
+        rows = conn.execute("SELECT key, value FROM settings").fetchall()
+        return {r["key"]: r["value"] for r in rows}
+
+
+# ── Analytics ────────────────────────────────────────────────────────────────
+
+def get_book_distribution(source_id: int = None) -> list[dict]:
+    with get_db() as conn:
+        if source_id:
+            rows = conn.execute(
+                """SELECT qr.book_code, COUNT(*) as count
+                   FROM quote_references qr
+                   JOIN quotes q ON qr.quote_id = q.id
+                   WHERE q.source_id = ? AND qr.book_code != ''
+                   GROUP BY qr.book_code ORDER BY count DESC""",
+                (source_id,),
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                """SELECT qr.book_code, COUNT(*) as count
+                   FROM quote_references qr
+                   JOIN quotes q ON qr.quote_id = q.id
+                   WHERE qr.book_code != ''
+                   GROUP BY qr.book_code ORDER BY count DESC"""
+            ).fetchall()
+        return [dict(r) for r in rows]
+
+
+def get_quote_type_distribution(source_id: int = None) -> dict:
+    with get_db() as conn:
+        if source_id:
+            rows = conn.execute(
+                "SELECT quote_type, COUNT(*) as count FROM quotes WHERE source_id=? GROUP BY quote_type",
+                (source_id,),
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                "SELECT quote_type, COUNT(*) as count FROM quotes GROUP BY quote_type"
+            ).fetchall()
+        return {r["quote_type"]: r["count"] for r in rows}
+
+
+def search_sources(filters: list[dict], logic: str = "AND") -> dict:
+    """
+    Search sources by text content and/or scripture references.
+
+    filters: list of dicts, each with:
+      - type: 'text' | 'book' | 'chapter' | 'verse'
+      - value: the query string (already lowercased by caller)
+    logic: 'AND' (source must match all filters) |
+           'OR'  (source must match any filter)
+
+    Returns {'total': int, 'results': [enriched source dicts]}
+    """
+    valid = [f for f in filters if f.get("value", "").strip()]
+    if not valid:
+        return {"total": 0, "results": []}
+
+    with get_db() as conn:
+        # --- per-filter: map source_id → list of evidence dicts ---------------
+        filter_evidence: list[dict[int, list[dict]]] = []
+
+        for f in valid:
+            ftype = f["type"]
+            fval  = f["value"].strip().lower()
+            ev: dict[int, list[dict]] = {}
+
+            if ftype == "text":
+                rows = conn.execute(
+                    "SELECT id, name, text FROM sources "
+                    "WHERE lower(text) LIKE ? OR lower(name) LIKE ?",
+                    [f"%{fval}%", f"%{fval}%"],
+                ).fetchall()
+                for r in rows:
+                    full = r["text"]
+                    idx  = full.lower().find(fval)
+                    if idx >= 0:
+                        s0 = max(0, idx - 100)
+                        s1 = min(len(full), idx + len(fval) + 100)
+                        pre  = ("…" if s0 > 0 else "")
+                        post = ("…" if s1 < len(full) else "")
+                        snippet = pre + full[s0:s1] + post
+                    else:
+                        # Query matched the source name, not the text body
+                        snippet = r["name"]
+                    ev[r["id"]] = ev.get(r["id"], [])
+                    ev[r["id"]].append({
+                        "kind": "text", "snippet": snippet,
+                        "query": f["value"], "offset": idx,
+                    })
+
+            elif ftype == "book":
+                rows = conn.execute(
+                    """SELECT DISTINCT q.source_id,
+                              qr.reference, q.quote_text, q.quote_type
+                       FROM quotes q
+                       JOIN quote_references qr ON qr.quote_id = q.id
+                       WHERE qr.book_code = ?""",
+                    [fval],
+                ).fetchall()
+                for r in rows:
+                    sid = r["source_id"]
+                    ev.setdefault(sid, [])
+                    ev[sid].append({
+                        "kind": "ref", "reference": r["reference"],
+                        "quote_text": r["quote_text"][:120],
+                        "quote_type": r["quote_type"],
+                    })
+
+            elif ftype == "chapter":
+                # fval is e.g. "gen_1"
+                rows = conn.execute(
+                    """SELECT DISTINCT q.source_id,
+                              qr.reference, q.quote_text, q.quote_type
+                       FROM quotes q
+                       JOIN quote_references qr ON qr.quote_id = q.id
+                       WHERE qr.reference LIKE ?""",
+                    [f"{fval}:%"],
+                ).fetchall()
+                for r in rows:
+                    sid = r["source_id"]
+                    ev.setdefault(sid, [])
+                    ev[sid].append({
+                        "kind": "ref", "reference": r["reference"],
+                        "quote_text": r["quote_text"][:120],
+                        "quote_type": r["quote_type"],
+                    })
+
+            elif ftype == "verse":
+                # fval is e.g. "gen_1:1"
+                rows = conn.execute(
+                    """SELECT DISTINCT q.source_id,
+                              qr.reference, q.quote_text, q.quote_type
+                       FROM quotes q
+                       JOIN quote_references qr ON qr.quote_id = q.id
+                       WHERE qr.reference = ?""",
+                    [fval],
+                ).fetchall()
+                for r in rows:
+                    sid = r["source_id"]
+                    ev.setdefault(sid, [])
+                    ev[sid].append({
+                        "kind": "ref", "reference": r["reference"],
+                        "quote_text": r["quote_text"][:120],
+                        "quote_type": r["quote_type"],
+                    })
+
+            filter_evidence.append(ev)
+
+        # --- combine filter result sets ---------------------------------------
+        id_sets = [set(ev.keys()) for ev in filter_evidence]
+        if logic == "AND":
+            matching: set[int] = id_sets[0]
+            for s in id_sets[1:]:
+                matching &= s
+        else:
+            matching = set()
+            for s in id_sets:
+                matching |= s
+
+        if not matching:
+            return {"total": 0, "results": []}
+
+        # --- fetch source rows with aggregate stats --------------------------
+        placeholders = ",".join("?" * len(matching))
+        src_rows = conn.execute(
+            f"""SELECT s.id, s.name, s.created_at,
+                       COUNT(q.id) as quote_count
+                FROM sources s
+                LEFT JOIN quotes q ON q.source_id = s.id
+                WHERE s.id IN ({placeholders})
+                GROUP BY s.id ORDER BY s.created_at DESC""",
+            list(matching),
+        ).fetchall()
+
+        results = []
+        for src in src_rows:
+            sd = dict(src)
+
+            # type distribution
+            td_rows = conn.execute(
+                "SELECT quote_type, COUNT(*) as c FROM quotes "
+                "WHERE source_id=? GROUP BY quote_type",
+                [sd["id"]],
+            ).fetchall()
+            sd["type_distribution"] = {r["quote_type"]: r["c"] for r in td_rows}
+
+            # book distribution (top 5)
+            bd_rows = conn.execute(
+                """SELECT qr.book_code, COUNT(*) as count
+                   FROM quote_references qr
+                   JOIN quotes q ON qr.quote_id = q.id
+                   WHERE q.source_id = ? AND qr.book_code != ''
+                   GROUP BY qr.book_code ORDER BY count DESC LIMIT 5""",
+                [sd["id"]],
+            ).fetchall()
+            sd["book_distribution"] = [dict(r) for r in bd_rows]
+
+            # aggregate evidence from all matching filters, deduplicate refs
+            all_ev: list[dict] = []
+            seen_refs: set[str] = set()
+            for ev in filter_evidence:
+                if sd["id"] in ev:
+                    for item in ev[sd["id"]]:
+                        if item["kind"] == "ref":
+                            key = item["reference"]
+                            if key in seen_refs:
+                                continue
+                            seen_refs.add(key)
+                        all_ev.append(item)
+            sd["match_evidence"] = all_ev[:10]
+
+            results.append(sd)
+
+        return {"total": len(results), "results": results}
+
+
+def get_dashboard_data() -> dict:
+    with get_db() as conn:
+        source_count = conn.execute("SELECT COUNT(*) as c FROM sources").fetchone()["c"]
+        quote_count = conn.execute("SELECT COUNT(*) as c FROM quotes").fetchone()["c"]
+        ref_count = conn.execute("SELECT COUNT(*) as c FROM quote_references").fetchone()["c"]
+
+        sources = conn.execute(
+            """SELECT s.id, s.name, s.created_at,
+                      COUNT(q.id) as quote_count
+               FROM sources s
+               LEFT JOIN quotes q ON q.source_id = s.id
+               GROUP BY s.id ORDER BY s.created_at DESC"""
+        ).fetchall()
+
+        return {
+            "source_count": source_count,
+            "quote_count": quote_count,
+            "reference_count": ref_count,
+            "sources": [dict(s) for s in sources],
+        }

main.py

@@ -0,0 +1,445 @@
+import json
+import csv
+import re
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from google import genai
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn, TimeElapsedColumn
+from rich import box
+
+PROJECT_ID = "cultural-heritage-gemini"
+LOCATION = "global"
+MODEL = "gemini-3-pro-preview"
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+PROBLEMS_DIR = PROJECT_ROOT / "data" / "task" / "problems"
+SOLUTIONS_DIR = PROJECT_ROOT / "data" / "task" / "solutions"
+REFERENCE_MAPPING_PATH = PROJECT_ROOT / "data" / "reference_mapping.json"
+BIBLE_TSV_PATH = PROJECT_ROOT / "data" / "bible.tsv"
+OUTPUT_DIR = PROJECT_ROOT / "output"
+
+console = Console()
+
+
+def load_reference_mapping() -> dict[str, str]:
+    with open(REFERENCE_MAPPING_PATH) as f:
+        return json.load(f)
+
+
+def load_problem(problem_id: str) -> str:
+    return (PROBLEMS_DIR / f"{problem_id}.txt").read_text(encoding="utf-8")
+
+
+def load_solution(problem_id: str) -> list[dict]:
+    with open(SOLUTIONS_DIR / f"{problem_id}.json") as f:
+        return json.load(f)
+
+
+def get_valid_book_codes() -> list[str]:
+    codes: set[str] = set()
+    with open(BIBLE_TSV_PATH, newline="") as f:
+        for row in csv.DictReader(f, delimiter="\t"):
+            codes.add(row["book_code"].strip().lower())
+    return sorted(codes)
+
+
+def build_prompt(text: str, valid_book_codes: list[str], ref_mapping: dict[str, str]) -> str:
+    codes_str = ", ".join(valid_book_codes)
+    mapping_lines = "\n".join(f"  {k} -> {v}" for k, v in sorted(ref_mapping.items()))
+    return f"""You are an expert in medieval Latin texts and the Latin Vulgate Bible.
+
+Given the following Latin text from a Carolingian-era ecclesiastical document, identify ALL scriptural (Biblical) quotations, partial quotations, paraphrases, and clear allusions to specific Bible verses.
+
+For each identified passage:
+1. Extract the EXACT text as it appears in the document — preserve the original spelling, punctuation, and word order verbatim.
+2. Identify the specific Bible verse(s) being quoted or referenced.
+3. Classify the type of reuse as one of:
+   - "full"       — a complete or near-complete verse quoted verbatim from the Vulgate.
+   - "partial"    — a recognisable portion of a verse, quoted with minor variation or truncation.
+   - "paraphrase" — the biblical content is clearly restated in different words while preserving the meaning.
+   - "allusion"   — a brief phrase, thematic echo, or indirect reference to a specific verse without quoting or restating it.
+
+Reference format: book_chapter:verse  (e.g. matt_5:9, ps_82:14, 1cor_15:33, dan_4:14)
+CRITICAL: Each reference must be a SINGLE verse. Never use ranges like matt_15:1-2.
+Instead, list each verse separately: matt_15:1, matt_15:2.
+
+Valid book codes: {codes_str}
+
+Common abbreviation-to-code mapping (for your reference):
+{mapping_lines}
+
+Important:
+- Include both direct quotes and partial quotes / paraphrases / allusions.
+- A single passage may reference multiple Bible verses — list all of them.
+- Use the Vulgate Latin text as your primary reference for identifying quotes.
+- Be thorough — identify even brief allusions to specific verses.
+- For Psalms, use the Vulgate / LXX numbering (which may differ from Hebrew numbering by 1).
+- The extracted text must be a verbatim substring of the input document.
+
+TEXT:
+{text}"""
+
+
+def extract_quotes_with_gemini(
+    text: str,
+    valid_book_codes: list[str],
+    ref_mapping: dict[str, str],
+) -> list[dict]:
+    client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)
+
+    prompt = build_prompt(text, valid_book_codes, ref_mapping)
+
+    response_schema = {
+        "type": "ARRAY",
+        "items": {
+            "type": "OBJECT",
+            "properties": {
+                "text": {
+                    "type": "STRING",
+                    "description": (
+                        "The exact text of the scriptural quote or allusion "
+                        "as it appears verbatim in the document"
+                    ),
+                },
+                "resolved_references": {
+                    "type": "ARRAY",
+                    "items": {"type": "STRING"},
+                    "description": (
+                        "List of Bible verse references in format "
+                        "book_chapter:verse (e.g. matt_5:9)"
+                    ),
+                },
+                "quote_type": {
+                    "type": "STRING",
+                    "enum": ["full", "partial", "paraphrase", "allusion"],
+                    "description": (
+                        "full = complete verse quoted verbatim, "
+                        "partial = recognisable portion with minor variation, "
+                        "paraphrase = biblical content restated in different words, "
+                        "allusion = brief phrase or thematic echo"
+                    ),
+                },
+            },
+            "required": ["text", "resolved_references", "quote_type"],
+        },
+    }
+
+    response = client.models.generate_content(
+        model=MODEL,
+        contents=prompt,
+        config={
+            "response_mime_type": "application/json",
+            "response_schema": response_schema,
+        },
+    )
+
+    quotes = json.loads(response.text)
+    for q in quotes:
+        q["resolved_references"] = expand_range_references(q.get("resolved_references", []))
+    return quotes
+
+
+def find_spans(text: str, quotes: list[dict]) -> list[dict]:
+    results = []
+    for quote in quotes:
+        qt = quote["text"]
+        idx = text.find(qt)
+        if idx == -1:
+            idx = text.lower().find(qt.lower())
+        span_start = idx if idx != -1 else None
+        span_end = (idx + len(qt)) if idx != -1 else None
+        results.append({
+            "text": qt,
+            "span_start": span_start,
+            "span_end": span_end,
+            "resolved_references": quote["resolved_references"],
+            "quote_type": quote.get("quote_type", "allusion"),
+        })
+    return results
+
+
+_RANGE_RE = re.compile(r"^(.+_\d+):(\d+)-(\d+)$")
+
+
+def expand_range_references(refs: list[str]) -> list[str]:
+    expanded: list[str] = []
+    for ref in refs:
+        m = _RANGE_RE.match(ref.strip())
+        if m:
+            prefix, start, end = m.group(1), int(m.group(2)), int(m.group(3))
+            for v in range(start, end + 1):
+                expanded.append(f"{prefix}:{v}")
+        else:
+            expanded.append(ref.strip())
+    return expanded
+
+
+def normalize_reference(ref: str) -> str:
+    return ref.strip().lower()
+
+
+def build_predictions(problem_id: str, quotes: list[dict]) -> list[dict]:
+    predictions = []
+    for quote in quotes:
+        for ref in quote.get("resolved_references", []):
+            predictions.append({
+                "problem_id": problem_id,
+                "reference": normalize_reference(ref),
+                "text": quote.get("text", ""),
+            })
+    return predictions
+
+
+def load_ground_truth(problem_id: str) -> dict[str, list[str]]:
+    solution = load_solution(problem_id)
+    refs: set[str] = set()
+    for item in solution:
+        for ref in item.get("resolved_references", []):
+            refs.add(normalize_reference(ref))
+    return {problem_id: sorted(refs)}
+
+
+def score_predictions(
+    predictions: list[dict],
+    ground_truth_by_problem: dict[str, list[str]],
+) -> dict:
+    pred_pairs: set[tuple[str, str]] = set()
+    for row in predictions:
+        pid = str(row.get("problem_id", "")).strip()
+        ref = normalize_reference(row.get("reference", ""))
+        if pid and ref:
+            pred_pairs.add((pid, ref))
+
+    true_pairs: set[tuple[str, str]] = set()
+    for problem_id, refs in ground_truth_by_problem.items():
+        for ref in refs:
+            true_pairs.add((problem_id, normalize_reference(ref)))
+
+    tp = len(pred_pairs & true_pairs)
+    fp = len(pred_pairs - true_pairs)
+    fn = len(true_pairs - pred_pairs)
+
+    precision = tp / (tp + fp) if (tp + fp) else 0.0
+    recall = tp / (tp + fn) if (tp + fn) else 0.0
+    f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) else 0.0
+
+    return {
+        "true_positives": tp,
+        "false_positives": fp,
+        "false_negatives": fn,
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "pred_pairs": pred_pairs,
+        "true_pairs": true_pairs,
+    }
+
+
+def display_results(
+    problem_id: str,
+    quotes_with_spans: list[dict],
+    metrics: dict,
+    ground_truth: dict[str, list[str]],
+) -> None:
+    console.print()
+    console.print(
+        Panel(
+            f"[bold]{TEAM_NAME}[/bold]  |  Problem: [cyan]{problem_id}[/cyan]  |  Model: [green]{MODEL}[/green]",
+            title="Ruse of Reuse — Scriptural Quote Detection",
+            border_style="blue",
+        )
+    )
+
+    qt = Table(title="Extracted Quotes", box=box.ROUNDED, show_lines=True)
+    qt.add_column("#", style="dim", width=3)
+    qt.add_column("Text", style="white", max_width=70)
+    qt.add_column("Type", style="magenta", width=8)
+    qt.add_column("References", style="cyan")
+    qt.add_column("Span", style="yellow")
+
+    type_colors = {"full": "green", "partial": "yellow", "paraphrase": "cyan", "allusion": "red"}
+    for i, q in enumerate(quotes_with_spans, 1):
+        span = (
+            f"{q['span_start']}–{q['span_end']}"
+            if q["span_start"] is not None
+            else "[red]NOT FOUND[/red]"
+        )
+        refs = ", ".join(q["resolved_references"])
+        t = q["text"]
+        display = (t[:67] + "...") if len(t) > 70 else t
+        qtype = q.get("quote_type", "allusion")
+        tc = type_colors.get(qtype, "white")
+        qt.add_row(str(i), display, f"[{tc}]{qtype}[/{tc}]", refs, span)
+    console.print(qt)
+
+    mt = Table(title="Evaluation Metrics", box=box.DOUBLE_EDGE)
+    mt.add_column("Metric", style="bold")
+    mt.add_column("Value", justify="right")
+    f1c = "green" if metrics["f1"] >= 0.7 else "yellow" if metrics["f1"] >= 0.4 else "red"
+    mt.add_row("True Positives", f"[green]{metrics['true_positives']}[/green]")
+    mt.add_row("False Positives", f"[red]{metrics['false_positives']}[/red]")
+    mt.add_row("False Negatives", f"[red]{metrics['false_negatives']}[/red]")
+    mt.add_row("Precision", f"{metrics['precision']:.4f}")
+    mt.add_row("Recall", f"{metrics['recall']:.4f}")
+    mt.add_row("F1 Score", f"[{f1c}]{metrics['f1']:.4f}[/{f1c}]")
+    console.print(mt)
+
+    pred_refs = {ref for _, ref in metrics["pred_pairs"]}
+    true_refs = {ref for _, ref in metrics["true_pairs"]}
+
+    ct = Table(title="Reference Comparison", box=box.ROUNDED, show_lines=True)
+    ct.add_column("Reference", style="white")
+    ct.add_column("Status", justify="center")
+
+    for ref in sorted(pred_refs | true_refs):
+        in_pred = ref in pred_refs
+        in_true = ref in true_refs
+        if in_pred and in_true:
+            status = "[green]TP (correct)[/green]"
+        elif in_pred:
+            status = "[red]FP (spurious)[/red]"
+        else:
+            status = "[yellow]FN (missed)[/yellow]"
+        ct.add_row(ref, status)
+    console.print(ct)
+
+
+def process_single(problem_id: str, valid_book_codes: list[str], ref_mapping: dict[str, str]) -> dict:
+    text = load_problem(problem_id)
+    quotes = extract_quotes_with_gemini(text, valid_book_codes, ref_mapping)
+    quotes_with_spans = find_spans(text, quotes)
+    predictions = build_predictions(problem_id, quotes)
+    ground_truth = load_ground_truth(problem_id)
+    metrics = score_predictions(predictions, ground_truth)
+
+    OUTPUT_DIR.mkdir(exist_ok=True)
+    serialisable_metrics = {
+        k: v for k, v in metrics.items() if k not in ("pred_pairs", "true_pairs")
+    }
+    output_payload = {
+        "problem_id": problem_id,
+        "team_name": TEAM_NAME,
+        "model": MODEL,
+        "quotes": [
+            {
+                "text": q["text"],
+                "span_start": q["span_start"],
+                "span_end": q["span_end"],
+                "resolved_references": q["resolved_references"],
+                "quote_type": q.get("quote_type", "allusion"),
+            }
+            for q in quotes_with_spans
+        ],
+        "metrics": serialisable_metrics,
+    }
+    out_path = OUTPUT_DIR / f"{problem_id}.json"
+    out_path.write_text(json.dumps(output_payload, indent=2, ensure_ascii=False), encoding="utf-8")
+    return {"problem_id": problem_id, "num_quotes": len(quotes), **serialisable_metrics}
+
+
+def all_problem_ids() -> list[str]:
+    return sorted(p.stem for p in PROBLEMS_DIR.glob("*.txt"))
+
+
+def main() -> None:
+    threads = 20
+    if len(sys.argv) > 1 and sys.argv[1] != "--all":
+        problem_ids = [sys.argv[1]]
+    else:
+        problem_ids = all_problem_ids()
+
+    console.print(
+        Panel(
+            f"[bold]{TEAM_NAME}[/bold]  |  Model: [green]{MODEL}[/green]  |  "
+            f"Problems: [cyan]{len(problem_ids)}[/cyan]  |  Threads: [cyan]{threads}[/cyan]",
+            title="Ruse of Reuse — Batch Extraction",
+            border_style="blue",
+        )
+    )
+
+    valid_book_codes = get_valid_book_codes()
+    ref_mapping = load_reference_mapping()
+
+    results: list[dict] = []
+    errors: list[tuple[str, str]] = []
+    t0 = time.time()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+        TextColumn("{task.completed}/{task.total}"),
+        TimeElapsedColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Processing", total=len(problem_ids))
+
+        with ThreadPoolExecutor(max_workers=threads) as pool:
+            futures = {
+                pool.submit(process_single, pid, valid_book_codes, ref_mapping): pid
+                for pid in problem_ids
+            }
+            for future in as_completed(futures):
+                pid = futures[future]
+                try:
+                    res = future.result()
+                    results.append(res)
+                except Exception as exc:
+                    errors.append((pid, str(exc)))
+                progress.update(task, advance=1, description=f"Done: {pid}")
+
+    elapsed = time.time() - t0
+    console.print(f"\n[bold green]Completed in {elapsed:.1f}s[/bold green]")
+
+    if errors:
+        et = Table(title="Errors", box=box.ROUNDED, style="red")
+        et.add_column("Problem")
+        et.add_column("Error")
+        for pid, err in errors:
+            et.add_row(pid, err[:120])
+        console.print(et)
+
+    results.sort(key=lambda r: r["problem_id"])
+    rt = Table(title="Results Summary", box=box.ROUNDED, show_lines=True)
+    rt.add_column("Problem", style="cyan")
+    rt.add_column("Quotes", justify="right")
+    rt.add_column("TP", justify="right", style="green")
+    rt.add_column("FP", justify="right", style="red")
+    rt.add_column("FN", justify="right", style="red")
+    rt.add_column("Prec", justify="right")
+    rt.add_column("Rec", justify="right")
+    rt.add_column("F1", justify="right")
+    for r in results:
+        f1v = r["f1"]
+        f1c = "green" if f1v >= 0.7 else "yellow" if f1v >= 0.4 else "red"
+        rt.add_row(
+            r["problem_id"], str(r["num_quotes"]),
+            str(r["true_positives"]), str(r["false_positives"]), str(r["false_negatives"]),
+            f"{r['precision']:.3f}", f"{r['recall']:.3f}", f"[{f1c}]{f1v:.3f}[/{f1c}]",
+        )
+
+    total_tp = sum(r["true_positives"] for r in results)
+    total_fp = sum(r["false_positives"] for r in results)
+    total_fn = sum(r["false_negatives"] for r in results)
+    total_p = total_tp / (total_tp + total_fp) if (total_tp + total_fp) else 0
+    total_r = total_tp / (total_tp + total_fn) if (total_tp + total_fn) else 0
+    total_f1 = 2 * total_p * total_r / (total_p + total_r) if (total_p + total_r) else 0
+    f1c = "green" if total_f1 >= 0.7 else "yellow" if total_f1 >= 0.4 else "red"
+    rt.add_row(
+        "[bold]TOTAL[/bold]", str(sum(r["num_quotes"] for r in results)),
+        f"[bold]{total_tp}[/bold]", f"[bold]{total_fp}[/bold]", f"[bold]{total_fn}[/bold]",
+        f"[bold]{total_p:.3f}[/bold]", f"[bold]{total_r:.3f}[/bold]",
+        f"[bold][{f1c}]{total_f1:.3f}[/{f1c}][/bold]",
+    )
+    console.print(rt)
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires      = ["setuptools>=68.2.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scripture_detector"
+version = "0.0.1"
+description = "Scripture Detector: A tool for detecting scripture in medieval texts."
+readme = {text = "", content-type = "text/plain"}
+authors = [
+    { name = "Martin Rocek", email = "silence.sys@gmail.com"},
+    { name = "Gleb Schmidt", email = "gleb.schmidt@ru.nl" },
+]
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+
+dependencies = [
+    "tomli; python_version < '3.11'",
+    "python-dotenv",
+    "tqdm",
+    "pandas",
+    "gdown",
+    "bs4",
+    "lxml",
+    "requests",
+    "openai",
+    "chromadb",
+    "sentence_transformers",
+    "google-genai>=1.66.0",
+    "rich>=14.3.3",
+    "flask>=3.1.3",
+]
+requires-python = ">=3.11.9"
+
+[project.optional-dependencies]
+dev = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/glsch"
+
+[tool.setuptools]
+py-modules = ["app", "database", "main"]
+packages = []

static/style.css

@@ -0,0 +1,478 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800;900&display=swap');
+
+/*
+ * Yale University Color Palette
+ * Primary: Yale Blue #00356b
+ * Bright Blue: #286dc0
+ * Light Blue: #63aaff
+ * Warm Gray: #978d85
+ * Light Gray bg: #f9f9f9
+ * Accent Gold: #f9be00
+ */
+
+:root {
+  --bg: #f4f4f2;
+  --bg-secondary: #ededeb;
+  --surface: #ffffff;
+  --text: #111827;
+  --text-secondary: #1f2937;
+  --muted: #6b7280;
+  --border: #ddd9d3;
+  --border-light: #ebe8e3;
+
+  /* Yale Primary Colors */
+  --primary: #00356b;
+  --primary-mid: #286dc0;
+  --primary-light: #63aaff;
+  --primary-pale: #e8f0fb;
+  --primary-subtle: rgba(0,53,107,.07);
+
+  /* Yale Accent */
+  --accent: #bd8b13;          /* Yale gold – muted for readability */
+  --accent-bright: #f9be00;   /* Yale gold – full saturation */
+  --accent-hover: #a37710;
+
+  /* Semantic colors (keeping semantic meaning, Yale-adjacent tones) */
+  --green: #2f7d32;
+  --red: #c62828;
+  --amber: #bd8b13;
+  --blue: #286dc0;
+
+  /* Quote type colors – adjusted for Yale palette harmony */
+  --full: #2f7d32;
+  --partial: #bd8b13;
+  --paraphrase: #0277bd;
+  --allusion: #6a1b9a;
+  --full-bg: rgba(47,125,50,.12);
+  --partial-bg: rgba(189,139,19,.12);
+  --paraphrase-bg: rgba(2,119,189,.12);
+  --allusion-bg: rgba(106,27,154,.12);
+
+  --radius: 10px;
+  --radius-lg: 14px;
+  --radius-sm: 7px;
+
+  --shadow-sm: 0 1px 2px rgba(0,0,0,.05), 0 1px 3px rgba(0,0,0,.06);
+  --shadow-md: 0 4px 6px rgba(0,0,0,.04), 0 2px 4px rgba(0,0,0,.06);
+  --shadow-lg: 0 10px 25px rgba(0,0,0,.07), 0 4px 10px rgba(0,0,0,.05);
+  --shadow-xl: 0 20px 40px rgba(0,0,0,.09), 0 8px 16px rgba(0,0,0,.05);
+
+  --transition: .2s cubic-bezier(.4,0,.2,1);
+}
+
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+  font-family: 'Inter', system-ui, -apple-system, BlinkMacSystemFont, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+/* ── Header ─────────────────────────────────────────────────────────── */
+
+.header {
+  background: var(--primary);
+  color: #ffffff;
+  padding: 0 32px;
+  height: 68px;
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  box-shadow: 0 2px 12px rgba(0,53,107,.35);
+  position: relative;
+  z-index: 100;
+}
+
+/* Yale gold accent stripe at top */
+.header::before {
+  content: '';
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  height: 3px;
+  background: var(--accent-bright);
+}
+
+.header-brand {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  text-decoration: none;
+  color: inherit;
+}
+
+.header-logo {
+  width: 36px;
+  height: 36px;
+  flex-shrink: 0;
+}
+
+.header-title {
+  font-size: 1.1rem;
+  font-weight: 800;
+  letter-spacing: -.01em;
+  color: #ffffff;
+}
+
+.header-subtitle {
+  font-size: .72rem;
+  color: rgba(255,255,255,.65);
+  font-weight: 500;
+  letter-spacing: .02em;
+}
+
+.header nav {
+  margin-left: auto;
+  display: flex;
+  gap: 4px;
+}
+
+.header nav a {
+  color: rgba(255,255,255,.75);
+  text-decoration: none;
+  font-size: .84rem;
+  font-weight: 500;
+  padding: 8px 16px;
+  border-radius: var(--radius-sm);
+  transition: var(--transition);
+  position: relative;
+}
+
+.header nav a:hover {
+  color: #fff;
+  background: rgba(255,255,255,.12);
+}
+
+.header nav a.active {
+  color: #fff;
+  background: rgba(255,255,255,.14);
+}
+
+.header nav a.active::after {
+  content: '';
+  position: absolute;
+  bottom: 0px;
+  left: 50%;
+  transform: translateX(-50%);
+  width: 20px;
+  height: 2px;
+  background: var(--accent-bright);
+  border-radius: 1px;
+}
+
+/* ── Buttons ────────────────────────────────────────────────────────── */
+
+.btn {
+  padding: 9px 20px;
+  border-radius: var(--radius-sm);
+  border: none;
+  font-size: .84rem;
+  font-weight: 600;
+  cursor: pointer;
+  transition: var(--transition);
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  font-family: inherit;
+  line-height: 1.4;
+}
+
+.btn:disabled { opacity: .5; cursor: not-allowed; }
+
+.btn-primary {
+  background: var(--primary);
+  color: #fff;
+  box-shadow: 0 2px 8px rgba(0,53,107,.25);
+}
+
+.btn-primary:hover:not(:disabled) {
+  background: #004a96;
+  box-shadow: 0 4px 12px rgba(0,53,107,.35);
+  transform: translateY(-1px);
+}
+
+.btn-ghost {
+  background: transparent;
+  color: var(--muted);
+  border: 1.5px solid var(--border);
+}
+
+.btn-ghost:hover {
+  background: var(--bg);
+  color: var(--text);
+  border-color: #b8b3ac;
+}
+
+.btn-danger {
+  background: var(--red);
+  color: #fff;
+  box-shadow: 0 2px 8px rgba(198,40,40,.25);
+}
+
+.btn-danger:hover {
+  background: #b71c1c;
+  transform: translateY(-1px);
+}
+
+.btn-accent {
+  background: var(--primary);
+  color: #fff;
+  border-left: 3px solid var(--accent-bright);
+}
+
+.btn-sm { padding: 5px 12px; font-size: .78rem; }
+.btn-lg { padding: 12px 28px; font-size: .95rem; border-radius: var(--radius); }
+
+/* ── Container ──────────────────────────────────────────────────────── */
+
+.container {
+  max-width: 1200px;
+  margin: 0 auto;
+  padding: 32px 24px;
+}
+
+/* ── Cards ──────────────────────────────────────────────────────────── */
+
+.card {
+  background: var(--surface);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-sm);
+  border: 1px solid var(--border-light);
+  padding: 24px;
+  transition: var(--transition);
+}
+
+.card:hover { box-shadow: var(--shadow-md); }
+
+.card h2 {
+  font-size: 1rem;
+  font-weight: 700;
+  margin-bottom: 20px;
+  padding-bottom: 14px;
+  border-bottom: 2px solid var(--primary-pale);
+  color: var(--primary);
+}
+
+.card h3 {
+  font-size: .8rem;
+  font-weight: 700;
+  margin-bottom: 14px;
+  text-transform: uppercase;
+  letter-spacing: .06em;
+  color: var(--muted);
+}
+
+/* ── Forms ──────────────────────────────────────────────────────────── */
+
+.field { margin-bottom: 18px; }
+
+.field label {
+  display: block;
+  font-size: .82rem;
+  font-weight: 600;
+  margin-bottom: 6px;
+  color: var(--text-secondary);
+}
+
+.field input, .field select, .field textarea {
+  width: 100%;
+  padding: 10px 14px;
+  border: 1.5px solid var(--border);
+  border-radius: var(--radius-sm);
+  font-size: .9rem;
+  font-family: inherit;
+  color: var(--text);
+  background: var(--surface);
+  transition: var(--transition);
+}
+
+.field input:focus, .field select:focus, .field textarea:focus {
+  outline: none;
+  border-color: var(--primary-mid);
+  box-shadow: 0 0 0 3px var(--primary-subtle);
+}
+
+.field .hint {
+  font-size: .74rem;
+  color: var(--muted);
+  margin-top: 6px;
+}
+
+.field .hint a { color: var(--primary-mid); text-decoration: none; }
+.field .hint a:hover { text-decoration: underline; }
+
+/* ── Modal ──────────────────────────────────────────────────────────── */
+
+.modal-overlay {
+  position: fixed;
+  inset: 0;
+  background: rgba(0,0,0,.5);
+  backdrop-filter: blur(4px);
+  -webkit-backdrop-filter: blur(4px);
+  z-index: 1000;
+  display: none;
+  align-items: center;
+  justify-content: center;
+  padding: 20px;
+  overflow-y: auto;
+}
+
+.modal-overlay.active { display: flex; }
+
+.modal {
+  background: var(--surface);
+  border-radius: var(--radius-lg);
+  padding: 32px;
+  width: 90%;
+  max-width: 600px;
+  box-shadow: var(--shadow-xl);
+  max-height: 90vh;
+  overflow-y: auto;
+  animation: modalIn .25s ease-out;
+  border-top: 4px solid var(--primary);
+}
+
+@keyframes modalIn {
+  from { opacity: 0; transform: scale(.96) translateY(8px); }
+  to { opacity: 1; transform: scale(1) translateY(0); }
+}
+
+.modal h2 {
+  font-size: 1.15rem;
+  font-weight: 700;
+  margin-bottom: 20px;
+  color: var(--primary);
+}
+
+.modal label {
+  display: block;
+  font-size: .82rem;
+  font-weight: 600;
+  margin-bottom: 6px;
+  margin-top: 18px;
+  color: var(--text-secondary);
+}
+
+.modal label:first-of-type { margin-top: 0; }
+
+.modal input, .modal textarea, .modal select {
+  width: 100%;
+  padding: 10px 14px;
+  border: 1.5px solid var(--border);
+  border-radius: var(--radius-sm);
+  font-size: .9rem;
+  font-family: inherit;
+  color: var(--text);
+  transition: var(--transition);
+}
+
+.modal input:focus, .modal textarea:focus, .modal select:focus {
+  outline: none;
+  border-color: var(--primary-mid);
+  box-shadow: 0 0 0 3px var(--primary-subtle);
+}
+
+.modal textarea { min-height: 200px; resize: vertical; }
+.modal .actions { display: flex; gap: 10px; justify-content: flex-end; margin-top: 24px; }
+
+/* ── Toast ──────────────────────────────────────────────────────────── */
+
+.toast {
+  position: fixed;
+  bottom: 24px;
+  right: 24px;
+  padding: 14px 24px;
+  border-radius: var(--radius);
+  color: #fff;
+  font-size: .88rem;
+  font-weight: 600;
+  box-shadow: var(--shadow-lg);
+  z-index: 1100;
+  transition: opacity .3s;
+  animation: toastIn .3s ease-out;
+}
+
+@keyframes toastIn {
+  from { opacity: 0; transform: translateY(12px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+.toast-ok { background: var(--green); }
+.toast-err { background: var(--red); }
+
+/* ── Empty State ────────────────────────────────────────────────────── */
+
+.empty-state { text-align: center; padding: 80px 20px; }
+.empty-state .empty-icon { width: 80px; height: 80px; margin: 0 auto 20px; opacity: .25; }
+.empty-state h2 { font-size: 1.3rem; font-weight: 700; margin-bottom: 10px; color: var(--text); }
+.empty-state p { color: var(--muted); margin-bottom: 24px; font-size: .95rem; max-width: 400px; margin-left: auto; margin-right: auto; }
+
+/* ── Loading ────────────────────────────────────────────────────────── */
+
+.loading {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 60px;
+  color: var(--muted);
+  font-size: .95rem;
+  gap: 12px;
+}
+
+@keyframes spin { to { transform: rotate(360deg); } }
+
+.spinner {
+  width: 22px;
+  height: 22px;
+  border: 2.5px solid var(--border);
+  border-top-color: var(--primary-mid);
+  border-radius: 50%;
+  animation: spin .7s linear infinite;
+}
+
+/* ── Type badges ────────────────────────────────────────────────────── */
+
+.type-badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: .68rem;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: .04em;
+}
+
+.type-full { background: rgba(47,125,50,.12); color: var(--full); }
+.type-partial { background: rgba(189,139,19,.12); color: var(--partial); }
+.type-paraphrase { background: rgba(2,119,189,.12); color: var(--paraphrase); }
+.type-allusion { background: rgba(106,27,154,.12); color: var(--allusion); }
+
+/* ── Type bar ───────────────────────────────────────────────────────── */
+
+.type-bar {
+  display: flex;
+  height: 8px;
+  border-radius: 4px;
+  overflow: hidden;
+  background: var(--bg-secondary);
+}
+
+.type-bar div { min-width: 3px; transition: width .4s ease; }
+
+.type-legend { display: flex; gap: 12px; flex-wrap: wrap; margin-top: 8px; }
+.type-legend-item { display: flex; align-items: center; gap: 5px; font-size: .74rem; color: var(--muted); }
+.type-legend-swatch { width: 10px; height: 10px; border-radius: 3px; }
+
+/* ── Scrollbar ──────────────────────────────────────────────────────── */
+
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: #c5bfb8; border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: #9e9891; }
+
+/* ── Selection ──────────────────────────────────────────────────────── */
+
+::selection { background: rgba(40,109,192,.2); }

tei.py

@@ -0,0 +1,289 @@
+"""TEI-XML export and import for Scripture Detector.
+
+Export schema
+─────────────
+  TEI
+  ├── teiHeader / fileDesc, encodingDesc
+  ├── text / body / ab   ← source text with inline <seg> for annotated spans
+  └── standOff / listAnnotation   ← one <annotation> per quote
+
+Import
+──────
+  Reads a TEI file produced by this module and reconstructs source name,
+  full text, and annotations (with character-offset spans).
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import date
+
+from lxml import etree
+
+TEI_NS = "http://www.tei-c.org/ns/1.0"
+XML_NS = "http://www.w3.org/XML/1998/namespace"
+
+_T  = f"{{{TEI_NS}}}"   # prefix shortcut
+_X  = f"{{{XML_NS}}}"   # xml: namespace prefix
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _compute_segments(text: str, annotations: list[dict]) -> list[dict]:
+    """Split *text* at annotation boundaries (same logic as app.compute_segments)."""
+    boundaries: set[int] = {0, len(text)}
+    for a in annotations:
+        if a.get("span_start") is not None and a.get("span_end") is not None:
+            boundaries.add(a["span_start"])
+            boundaries.add(a["span_end"])
+    ordered = sorted(boundaries)
+    segments = []
+    for i in range(len(ordered) - 1):
+        start, end = ordered[i], ordered[i + 1]
+        ann_ids = [
+            j for j, a in enumerate(annotations)
+            if a.get("span_start") is not None
+            and a["span_start"] <= start and end <= a["span_end"]
+        ]
+        segments.append({"text": text[start:end], "start": start, "end": end,
+                          "annotation_ids": ann_ids})
+    return segments
+
+
+def _ref_label(ref: str, book_names: dict[str, str]) -> str:
+    """'gen_1:5'  →  'Genesis 1:5'"""
+    ref = ref.strip().lower()
+    m = re.match(r"^([a-z0-9]+)_(\d+):(\d+)$", ref)
+    if m:
+        book_code, ch, vs = m.groups()
+        book = book_names.get(book_code, book_code.capitalize())
+        return f"{book} {ch}:{vs}"
+    m2 = re.match(r"^([a-z0-9]+)_(\d+)$", ref)
+    if m2:
+        book_code, ch = m2.groups()
+        book = book_names.get(book_code, book_code.capitalize())
+        return f"{book} {ch}"
+    return ref
+
+
+# ── export ────────────────────────────────────────────────────────────────────
+
+def source_to_tei(
+    source: dict,
+    annotations: list[dict],
+    book_names: dict[str, str] | None = None,
+) -> bytes:
+    """
+    Serialise *source* + *annotations* as UTF-8 TEI XML bytes.
+
+    source:      dict with keys id, name, text, created_at
+    annotations: list of dicts with keys id, span_start, span_end,
+                 quote_text, quote_type, refs
+    book_names:  {book_code: human_name} — used for human-readable <ref> labels
+    """
+    book_names = book_names or {}
+
+    NSMAP = {None: TEI_NS}
+    root = etree.Element(f"{_T}TEI", nsmap=NSMAP)
+
+    # ── teiHeader ────────────────────────────────────────────────────────────
+    header     = etree.SubElement(root,   f"{_T}teiHeader")
+    fileDesc   = etree.SubElement(header, f"{_T}fileDesc")
+    titleStmt  = etree.SubElement(fileDesc, f"{_T}titleStmt")
+    title_el   = etree.SubElement(titleStmt, f"{_T}title")
+    title_el.text = source["name"]
+    resp       = etree.SubElement(titleStmt, f"{_T}respStmt")
+    resp_resp  = etree.SubElement(resp, f"{_T}resp")
+    resp_resp.text = "Analyzed by"
+    resp_name  = etree.SubElement(resp, f"{_T}name")
+    resp_name.text = "Scripture Detector (Dr. William J.B. Mattingly, Yale University)"
+    pubStmt    = etree.SubElement(fileDesc, f"{_T}publicationStmt")
+    pub_p      = etree.SubElement(pubStmt, f"{_T}p")
+    pub_p.text = (
+        f"Exported from Scripture Detector on {date.today().isoformat()}. "
+        "Scripture Detector is developed by Dr. William J.B. Mattingly, "
+        "Cultural Heritage Data Scientist, Yale University."
+    )
+    srcDesc    = etree.SubElement(fileDesc, f"{_T}sourceDesc")
+    src_p      = etree.SubElement(srcDesc,  f"{_T}p")
+    src_p.text = "AI-assisted detection of biblical quotations, paraphrases, and allusions."
+
+    encDesc    = etree.SubElement(header, f"{_T}encodingDesc")
+    projDesc   = etree.SubElement(encDesc, f"{_T}projectDesc")
+    proj_p     = etree.SubElement(projDesc, f"{_T}p")
+    proj_p.text = (
+        "Scripture Detector uses Google Gemini to identify and classify biblical "
+        "references in historical texts. Reference types follow a four-level taxonomy."
+    )
+    clasDecl   = etree.SubElement(encDesc, f"{_T}classDecl")
+    taxonomy   = etree.SubElement(clasDecl, f"{_T}taxonomy")
+    taxonomy.set(f"{_X}id", "sd-types")
+    for cat_id, desc in [
+        ("sd-full",       "Full quotation: verbatim or near-verbatim citation of a biblical verse"),
+        ("sd-partial",    "Partial quotation: a recognisable portion of a verse"),
+        ("sd-paraphrase", "Paraphrase: biblical content restated in different words"),
+        ("sd-allusion",   "Allusion: brief thematic or verbal echo of a scriptural passage"),
+    ]:
+        cat = etree.SubElement(taxonomy, f"{_T}category")
+        cat.set(f"{_X}id", cat_id)
+        catDesc = etree.SubElement(cat, f"{_T}catDesc")
+        catDesc.text = desc
+
+    # ── text / body / ab ─────────────────────────────────────────────────────
+    text_el = etree.SubElement(root,    f"{_T}text")
+    body    = etree.SubElement(text_el, f"{_T}body")
+    ab      = etree.SubElement(body,    f"{_T}ab")
+    ab.set(f"{_X}id", "source-text")
+
+    segments = _compute_segments(source["text"], annotations)
+    last_el  = None  # most-recently appended child element
+
+    for seg in segments:
+        raw = seg["text"]
+        if not seg["annotation_ids"]:
+            # plain text: append to .text of <ab> or .tail of last element
+            if last_el is None:
+                ab.text = (ab.text or "") + raw
+            else:
+                last_el.tail = (last_el.tail or "") + raw
+        else:
+            ann_refs = " ".join(
+                f"#ann{annotations[i]['id']}" for i in seg["annotation_ids"]
+            )
+            subtypes = {annotations[i]["quote_type"] for i in seg["annotation_ids"]}
+            subtype  = next(iter(subtypes)) if len(subtypes) == 1 else "mixed"
+
+            seg_el = etree.SubElement(ab, f"{_T}seg")
+            seg_el.set(f"{_X}id",  f"seg{seg['start']}x{seg['end']}")
+            seg_el.set("ana",      ann_refs)
+            seg_el.set("type",     "biblical-reference")
+            seg_el.set("subtype",  subtype)
+            seg_el.text = raw
+            last_el = seg_el
+
+    # ── standOff ─────────────────────────────────────────────────────────────
+    stand_off = etree.SubElement(root,       f"{_T}standOff")
+    list_ann  = etree.SubElement(stand_off,  f"{_T}listAnnotation")
+
+    for a in annotations:
+        ann_el = etree.SubElement(list_ann, f"{_T}annotation")
+        ann_el.set(f"{_X}id", f"ann{a['id']}")
+        ann_el.set("type",    "biblical-reference")
+        ann_el.set("subtype", a.get("quote_type", "allusion"))
+        ann_el.set("ana",     f"#sd-{a.get('quote_type','allusion')}")
+
+        note_el = etree.SubElement(ann_el, f"{_T}note")
+        note_el.set("type", "quotedText")
+        note_el.text = a.get("quote_text", "")
+
+        refs_el = etree.SubElement(ann_el, f"{_T}listRef")
+        for ref in (a.get("refs") or []):
+            ref_clean = ref.strip().lower()
+            ref_el = etree.SubElement(refs_el, f"{_T}ref")
+            ref_el.set("target", f"bible:{ref_clean}")
+            ref_el.text = _ref_label(ref_clean, book_names)
+
+    return etree.tostring(
+        root,
+        pretty_print=True,
+        xml_declaration=True,
+        encoding="UTF-8",
+    )
+
+
+# ── import ────────────────────────────────────────────────────────────────────
+
+def tei_to_source_data(xml_bytes: bytes) -> dict:
+    """
+    Parse a TEI file produced by :func:`source_to_tei`.
+
+    Returns a dict::
+
+        {
+          "name":  str,
+          "text":  str,
+          "annotations": [
+              {
+                  "quote_text":  str,
+                  "quote_type":  str,
+                  "refs":        [str, ...],
+                  "span_start":  int | None,
+                  "span_end":    int | None,
+              },
+              ...
+          ]
+        }
+    """
+    root = etree.fromstring(xml_bytes)
+
+    # ── source name ──────────────────────────────────────────────────────────
+    title_el = root.find(f".//{_T}teiHeader//{_T}titleStmt/{_T}title")
+    name = (title_el.text or "Untitled").strip() if title_el is not None else "Untitled"
+
+    # ── reconstruct plain text + offset map for <seg> ids ────────────────────
+    ab = root.find(f".//{_T}body//{_T}ab")
+    if ab is None:
+        ab = root.find(f".//{_T}body")
+
+    text_parts: list[str] = []
+    # Maps xml:id → (start_char, end_char) offsets within the joined text
+    offset_map: dict[str, tuple[int, int]] = {}
+
+    def _walk(el: etree._Element) -> None:
+        if el.text:
+            text_parts.append(el.text)
+        for child in el:
+            child_start = sum(len(p) for p in text_parts)
+            _walk(child)
+            child_end = sum(len(p) for p in text_parts)
+            xml_id = child.get(f"{_X}id")
+            if xml_id:
+                offset_map[xml_id] = (child_start, child_end)
+            if child.tail:
+                text_parts.append(child.tail)
+
+    if ab is not None:
+        _walk(ab)
+
+    full_text = "".join(text_parts)
+
+    # ── parse standOff annotations ────────────────────────────────────────────
+    annotations: list[dict] = []
+
+    for ann_el in root.findall(f".//{_T}standOff//{_T}annotation"):
+        ann_xml_id = ann_el.get(f"{_X}id", "")
+        subtype    = ann_el.get("subtype", "allusion")
+
+        note_el    = ann_el.find(f"{_T}note[@type='quotedText']")
+        quote_text = (note_el.text or "").strip() if note_el is not None else ""
+
+        refs: list[str] = []
+        for ref_el in ann_el.findall(f".//{_T}ref"):
+            target = ref_el.get("target", "")
+            if target.startswith("bible:"):
+                refs.append(target[6:])
+
+        # Determine character span from the seg elements referencing this annotation
+        span_start = span_end = None
+        if ab is not None and ann_xml_id:
+            ref_key = f"#{ann_xml_id}"
+            seg_offsets = []
+            for seg_el in ab.iter(f"{_T}seg"):
+                ana_val = seg_el.get("ana", "")
+                if ref_key in ana_val.split():
+                    seg_id = seg_el.get(f"{_X}id")
+                    if seg_id and seg_id in offset_map:
+                        seg_offsets.append(offset_map[seg_id])
+            if seg_offsets:
+                span_start = min(s for s, _ in seg_offsets)
+                span_end   = max(e for _, e in seg_offsets)
+
+        annotations.append({
+            "quote_text":  quote_text,
+            "quote_type":  subtype,
+            "refs":        refs,
+            "span_start":  span_start,
+            "span_end":    span_end,
+        })
+
+    return {"name": name, "text": full_text, "annotations": annotations}

templates/about.html

@@ -0,0 +1,550 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Scripture Detector — About</title>
+<link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+<link rel="stylesheet" href="/static/style.css">
+<style>
+  .container { max-width: 860px; }
+
+  /* Hero */
+  .hero {
+    background: var(--primary);
+    color: #fff;
+    padding: 56px 32px;
+    text-align: center;
+    position: relative;
+    overflow: hidden;
+  }
+  .hero::before {
+    content: '';
+    position: absolute;
+    top: 0; left: 0; right: 0;
+    height: 3px;
+    background: var(--accent-bright);
+  }
+  .hero-logo {
+    width: 72px;
+    height: 72px;
+    margin: 0 auto 20px;
+    filter: brightness(10);
+    opacity: .9;
+  }
+  .hero h1 {
+    font-size: 2rem;
+    font-weight: 900;
+    letter-spacing: -.03em;
+    margin-bottom: 12px;
+    color: #fff;
+  }
+  .hero p {
+    font-size: 1.08rem;
+    color: rgba(255,255,255,.8);
+    max-width: 560px;
+    margin: 0 auto;
+    line-height: 1.65;
+  }
+  .hero-badges {
+    display: flex;
+    gap: 10px;
+    justify-content: center;
+    margin-top: 22px;
+    flex-wrap: wrap;
+  }
+  .hero-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    background: rgba(255,255,255,.12);
+    border: 1px solid rgba(255,255,255,.2);
+    color: #fff;
+    font-size: .8rem;
+    font-weight: 600;
+    padding: 6px 14px;
+    border-radius: 20px;
+  }
+  .hero-badge .dot {
+    width: 7px; height: 7px;
+    border-radius: 50%;
+    background: var(--accent-bright);
+    flex-shrink: 0;
+  }
+
+  /* Cards */
+  .about-grid { display: grid; gap: 24px; margin-top: 32px; }
+
+  .about-card {
+    background: var(--surface);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-sm);
+    border: 1px solid var(--border-light);
+    padding: 28px 32px;
+    border-top: 3px solid var(--primary);
+  }
+
+  .about-card h2 {
+    font-size: 1.05rem;
+    font-weight: 800;
+    color: var(--primary);
+    margin-bottom: 16px;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+  }
+
+  .about-card h2 .icon {
+    width: 32px;
+    height: 32px;
+    background: var(--primary-pale);
+    border-radius: 8px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--primary);
+    flex-shrink: 0;
+  }
+
+  .about-card p {
+    color: var(--text-secondary);
+    line-height: 1.75;
+    font-size: .92rem;
+    margin-bottom: 14px;
+  }
+  .about-card p:last-child { margin-bottom: 0; }
+
+  .about-card ul {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+  }
+  .about-card ul li {
+    display: flex;
+    align-items: flex-start;
+    gap: 10px;
+    font-size: .9rem;
+    color: var(--text-secondary);
+    line-height: 1.55;
+  }
+  .about-card ul li::before {
+    content: '';
+    width: 6px;
+    height: 6px;
+    border-radius: 50%;
+    background: var(--accent-bright);
+    margin-top: 7px;
+    flex-shrink: 0;
+  }
+
+  /* Steps */
+  .steps { display: flex; flex-direction: column; gap: 0; }
+  .step {
+    display: grid;
+    grid-template-columns: 40px 1fr;
+    gap: 16px;
+    position: relative;
+  }
+  .step:not(:last-child)::after {
+    content: '';
+    position: absolute;
+    left: 19px;
+    top: 44px;
+    bottom: -14px;
+    width: 2px;
+    background: var(--primary-pale);
+  }
+  .step-num {
+    width: 40px;
+    height: 40px;
+    border-radius: 50%;
+    background: var(--primary);
+    color: #fff;
+    font-weight: 800;
+    font-size: .9rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    position: relative;
+    z-index: 1;
+  }
+  .step-body { padding-bottom: 24px; }
+  .step-body h3 { font-size: .95rem; font-weight: 700; color: var(--text); margin-bottom: 4px; }
+  .step-body p { font-size: .86rem; color: var(--muted); line-height: 1.6; }
+
+  /* Quote types */
+  .type-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; }
+  @media (max-width: 600px) { .type-grid { grid-template-columns: 1fr; } }
+  .type-item {
+    padding: 14px 16px;
+    border-radius: var(--radius);
+    border-left: 4px solid;
+  }
+  .type-item.full { background: var(--full-bg); border-color: var(--full); }
+  .type-item.partial { background: var(--partial-bg); border-color: var(--partial); }
+  .type-item.paraphrase { background: var(--paraphrase-bg); border-color: var(--paraphrase); }
+  .type-item.allusion { background: var(--allusion-bg); border-color: var(--allusion); }
+  .type-item strong { font-size: .84rem; font-weight: 700; display: block; margin-bottom: 3px; }
+  .type-item p { font-size: .8rem; color: var(--muted); line-height: 1.5; margin: 0; }
+  .type-item.full strong { color: var(--full); }
+  .type-item.partial strong { color: var(--partial); }
+  .type-item.paraphrase strong { color: var(--paraphrase); }
+  .type-item.allusion strong { color: var(--allusion); }
+
+  /* Screenshot gallery */
+  .screenshot-grid { display: grid; gap: 20px; }
+  .screenshot-item { border-radius: var(--radius); overflow: hidden; border: 1px solid var(--border); box-shadow: var(--shadow-md); }
+  .screenshot-item img { width: 100%; display: block; }
+  .screenshot-caption { padding: 10px 14px; background: var(--bg-secondary); font-size: .8rem; color: var(--muted); font-weight: 500; }
+
+  /* Author card */
+  .author-card {
+    background: var(--primary);
+    color: #fff;
+    border-radius: var(--radius-lg);
+    padding: 28px 32px;
+    display: flex;
+    gap: 24px;
+    align-items: flex-start;
+    flex-wrap: wrap;
+    margin-top: 24px;
+    position: relative;
+    overflow: hidden;
+  }
+  .author-card::after {
+    content: '';
+    position: absolute;
+    bottom: 0; right: 0;
+    width: 160px; height: 160px;
+    background: rgba(255,255,255,.04);
+    border-radius: 50%;
+    transform: translate(40%, 40%);
+  }
+  .author-icon {
+    width: 60px; height: 60px;
+    border-radius: 50%;
+    background: rgba(255,255,255,.15);
+    display: flex; align-items: center; justify-content: center;
+    font-size: 1.8rem;
+    flex-shrink: 0;
+  }
+  .author-info h3 { font-size: 1.1rem; font-weight: 800; margin-bottom: 3px; color: #fff; }
+  .author-info .role { font-size: .84rem; color: rgba(255,255,255,.7); margin-bottom: 10px; }
+  .author-info p { font-size: .88rem; color: rgba(255,255,255,.8); line-height: 1.65; max-width: 540px; }
+  .author-info a { color: var(--accent-bright); text-decoration: none; }
+  .author-info a:hover { text-decoration: underline; }
+
+  /* Workshop banner */
+  .workshop-banner {
+    background: var(--primary-pale);
+    border: 1.5px solid #c9dcf5;
+    border-radius: var(--radius);
+    padding: 18px 22px;
+    display: flex;
+    gap: 16px;
+    align-items: flex-start;
+    margin-top: 12px;
+  }
+  .workshop-banner .ws-icon {
+    width: 40px; height: 40px;
+    background: var(--primary);
+    border-radius: 8px;
+    display: flex; align-items: center; justify-content: center;
+    color: #fff;
+    flex-shrink: 0;
+  }
+  .workshop-banner .ws-info h4 { font-size: .9rem; font-weight: 700; color: var(--primary); margin-bottom: 3px; }
+  .workshop-banner .ws-info p { font-size: .82rem; color: var(--muted); line-height: 1.5; margin: 0; }
+  .workshop-banner .ws-info a { color: var(--primary-mid); }
+
+  /* API key note */
+  .api-note {
+    display: flex;
+    align-items: flex-start;
+    gap: 14px;
+    background: rgba(249,190,0,.1);
+    border: 1.5px solid rgba(189,139,19,.3);
+    border-radius: var(--radius);
+    padding: 16px 20px;
+    margin-top: 14px;
+  }
+  .api-note-icon {
+    font-size: 1.4rem;
+    flex-shrink: 0;
+    line-height: 1;
+  }
+  .api-note p { font-size: .86rem; color: var(--text-secondary); line-height: 1.6; margin: 0; }
+  .api-note a { color: var(--primary-mid); font-weight: 600; text-decoration: none; }
+  .api-note a:hover { text-decoration: underline; }
+
+  /* Screenshots section */
+  .screenshots-container { margin-top: 12px; }
+  .screenshots-container .screenshot-item img { border-radius: 0; }
+</style>
+</head>
+<body>
+
+<div class="header">
+  <a href="/" class="header-brand">
+    <img src="/static/logo.svg" alt="Logo" class="header-logo">
+    <div>
+      <div class="header-title">Scripture Detector</div>
+      <div class="header-subtitle">About</div>
+    </div>
+  </a>
+  <nav>
+    <a href="/">Sources</a>
+    <a href="/dashboard">Dashboard</a>
+    <a href="/about" class="active">About</a>
+    <a href="/settings">Settings</a>
+  </nav>
+</div>
+
+<!-- Hero -->
+<div class="hero">
+  <img src="/static/logo.svg" alt="Scripture Detector Logo" class="hero-logo">
+  <h1>Scripture Detector</h1>
+  <p>An AI-powered tool for detecting, classifying, and analyzing biblical quotations, paraphrases, and allusions in historical texts — powered by Google Gemini.</p>
+  <div class="hero-badges">
+    <span class="hero-badge"><span class="dot"></span>Powered by Google Gemini</span>
+    <span class="hero-badge"><span class="dot"></span>Yale University</span>
+    <span class="hero-badge"><span class="dot"></span>Open Source</span>
+  </div>
+</div>
+
+<div class="container">
+  <div class="about-grid">
+
+    <!-- Author -->
+    <div class="author-card">
+      <div class="author-icon">👤</div>
+      <div class="author-info">
+        <h3>Dr. William J.B. Mattingly</h3>
+        <div class="role">Cultural Heritage Data Scientist · Yale University</div>
+        <p>
+          Scripture Detector was developed by Dr. William J.B. Mattingly, Cultural Heritage Data Scientist at Yale University. The application was built for the international workshop
+          <strong><a href="https://www.oeaw.ac.at/en/imafo/events/event-details/ruse-of-reuse" target="_blank">Ruse of Reuse: Detecting Text-similarity with AI in Historical Sources</a></strong>
+          (March 5–6, 2026), hosted by the Austrian Academy of Sciences in Vienna.
+        </p>
+        <div class="workshop-banner" style="background:rgba(255,255,255,.08);border-color:rgba(255,255,255,.15);margin-top:14px">
+          <div class="ws-icon">
+            <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><rect x="3" y="4" width="18" height="18" rx="2"/><line x1="16" y1="2" x2="16" y2="6"/><line x1="8" y1="2" x2="8" y2="6"/><line x1="3" y1="10" x2="21" y2="10"/></svg>
+          </div>
+          <div class="ws-info" style="color:rgba(255,255,255,.85)">
+            <h4 style="color:#f9be00">Ruse of Reuse Workshop · March 5–6, 2026</h4>
+            <p style="color:rgba(255,255,255,.7)">Austrian Academy of Sciences · PSK, Georg-Coch-Platz 2, 1010 Vienna<br>
+            Organised by the Digital Lab, Institute for Medieval Research, Austrian Academy of Sciences &amp; SOLEMNE, Radboud University</p>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- What it does -->
+    <div class="about-card">
+      <h2>
+        <span class="icon">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
+        </span>
+        What is Scripture Detector?
+      </h2>
+      <p>
+        Scripture Detector is an AI-powered web application that analyzes historical and literary texts to find and classify all the ways biblical scripture appears within them. Given any piece of text, the application uses large language models to locate exact quotations, partial quotations, paraphrases, and allusions to specific Bible verses.
+      </p>
+      <p>
+        Each detected passage is linked to the exact verse(s) it references, displayed in context within the original document, and explored through interactive visualizations. The application is designed for scholars, students, and researchers working with texts that draw on the biblical tradition.
+      </p>
+    </div>
+
+    <!-- How it works -->
+    <div class="about-card">
+      <h2>
+        <span class="icon">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/></svg>
+        </span>
+        How It Works
+      </h2>
+      <div class="steps">
+        <div class="step">
+          <div class="step-num">1</div>
+          <div class="step-body">
+            <h3>Add a Source Text</h3>
+            <p>Paste any text you want to analyze — a sermon, a letter, a medieval chronicle, a theological treatise — into the Sources page. The text is stored locally in a SQLite database.</p>
+          </div>
+        </div>
+        <div class="step">
+          <div class="step-num">2</div>
+          <div class="step-body">
+            <h3>AI Detection via Google Gemini</h3>
+            <p>Click "Process with AI" to send the text to Google Gemini with a carefully engineered prompt. The model returns a structured JSON list of all detected scriptural passages, their verse references, and classification types. Only a free Gemini API key is required.</p>
+          </div>
+        </div>
+        <div class="step">
+          <div class="step-num">3</div>
+          <div class="step-body">
+            <h3>Span Location &amp; Annotation</h3>
+            <p>The app finds the exact character span of each detected quote within the original text, then stores annotations linking text spans to specific Bible verses using a full verse database.</p>
+          </div>
+        </div>
+        <div class="step">
+          <div class="step-num">4</div>
+          <div class="step-body">
+            <h3>Interactive Exploration</h3>
+            <p>View color-coded highlights directly in the text, click any passage to see the verse references and original Bible text side-by-side, edit or add annotations manually, and explore distribution charts by Bible book, testament, and quote type.</p>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Quote type classifications -->
+    <div class="about-card">
+      <h2>
+        <span class="icon">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><path d="M9 3H5a2 2 0 00-2 2v4m6-6h10a2 2 0 012 2v4M9 3v18m0 0h10a2 2 0 002-2V9M9 21H5a2 2 0 01-2-2V9m0 0h18"/></svg>
+        </span>
+        Quote Classification Types
+      </h2>
+      <p>The AI classifies each detected passage into one of four categories:</p>
+      <div class="type-grid">
+        <div class="type-item full">
+          <strong>Full</strong>
+          <p>A complete or near-complete verse quoted verbatim from the Bible.</p>
+        </div>
+        <div class="type-item partial">
+          <strong>Partial</strong>
+          <p>A recognizable portion of a verse, quoted with minor variation or truncation.</p>
+        </div>
+        <div class="type-item paraphrase">
+          <strong>Paraphrase</strong>
+          <p>Biblical content clearly restated in different words while preserving the meaning.</p>
+        </div>
+        <div class="type-item allusion">
+          <strong>Allusion</strong>
+          <p>A brief phrase, thematic echo, or indirect reference to a specific verse.</p>
+        </div>
+      </div>
+    </div>
+
+    <!-- Technical requirements -->
+    <div class="about-card">
+      <h2>
+        <span class="icon">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><rect x="2" y="3" width="20" height="14" rx="2"/><line x1="8" y1="21" x2="16" y2="21"/><line x1="12" y1="17" x2="12" y2="21"/></svg>
+        </span>
+        Technical Requirements
+      </h2>
+      <ul>
+        <li>Python 3.10+ with Flask — the entire backend runs as a lightweight local web application.</li>
+        <li>SQLite — all sources, annotations, and settings are stored in a local database with no external server required.</li>
+        <li>A full Bible verse database (35,000+ verses) is included and used for verse lookup and reference validation.</li>
+        <li>Google Vertex AI or a Gemini API key from <a href="https://aistudio.google.com/apikey" target="_blank" style="color:var(--primary-mid);font-weight:600">Google AI Studio</a> — this is the only external dependency and is free to obtain.</li>
+      </ul>
+      <div class="api-note">
+        <div class="api-note-icon">🔑</div>
+        <p>
+          <strong>Only a free Gemini API key is required.</strong> Get yours at
+          <a href="https://aistudio.google.com/apikey" target="_blank">aistudio.google.com/apikey</a>
+          and enter it in the <a href="/settings">Settings</a> page to start using the app immediately.
+          No cloud account, credit card, or additional setup is needed.
+        </p>
+      </div>
+    </div>
+
+    <!-- Advanced Search -->
+    <div class="about-card">
+      <h2>
+        <span class="icon">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
+        </span>
+        Advanced Search
+      </h2>
+      <p>
+        The Sources page includes a powerful multi-layered search system that lets you find sources by their text content, the Bible books they reference, specific chapters, or individual verses — all updating in real time as you type.
+      </p>
+      <div class="type-grid" style="margin-top:14px">
+        <div class="type-item" style="background:rgba(0,53,107,.06);border-color:var(--primary)">
+          <strong style="color:var(--primary)">Text Content</strong>
+          <p>Full-text search across all source documents. Matching passages are highlighted in context with the search term shown inline.</p>
+        </div>
+        <div class="type-item" style="background:rgba(0,53,107,.06);border-color:var(--primary-mid)">
+          <strong style="color:var(--primary-mid)">Bible Book</strong>
+          <p>Find all sources that contain any reference to a chosen Bible book, using a searchable dropdown of all 73 books.</p>
+        </div>
+        <div class="type-item" style="background:rgba(0,53,107,.06);border-color:var(--primary-light)">
+          <strong style="color:var(--primary)">Chapter</strong>
+          <p>Narrow results to sources referencing a specific chapter (e.g. Psalms 23) using cascading book → chapter selectors.</p>
+        </div>
+        <div class="type-item" style="background:rgba(249,190,0,.1);border-color:var(--accent)">
+          <strong style="color:var(--accent-hover)">Verse</strong>
+          <p>Pinpoint sources that reference a specific verse (e.g. John 3:16) using book → chapter → verse number selectors.</p>
+        </div>
+      </div>
+      <p style="margin-top:16px">
+        <strong>Stacked filters with AND / OR logic</strong> — click <em>Advanced</em> to open the filter builder and stack any number of filters. Toggle between AND (source must match <em>all</em> filters) and OR (source must match <em>any</em> filter). Active filters are summarized as removable chips below the search bar. Match evidence appears directly on each source card, showing the exact text snippet or the matched verse and quote.
+      </p>
+    </div>
+
+    <!-- Features -->
+    <div class="about-card">
+      <h2>
+        <span class="icon">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="20 6 9 17 4 12"/></svg>
+        </span>
+        Key Features
+      </h2>
+      <ul>
+        <li>Full-text AI analysis using Google Gemini with structured JSON output.</li>
+        <li>Color-coded in-text annotations with click-to-explore interactivity.</li>
+        <li>Selection-based re-analysis: highlight any passage and re-run AI detection on just that section.</li>
+        <li>Manual annotation editor with a Bible verse picker (book → chapter → verse).</li>
+        <li><strong>Advanced search</strong> with real-time filtering by text content, Bible book, chapter, or verse — stackable filters with AND / OR logic and inline match evidence.</li>
+        <li>Distribution charts showing which Bible books and testaments are most referenced.</li>
+        <li>Global analytics dashboard across all sources.</li>
+        <li>Support for both Gemini API (free tier) and Google Vertex AI.</li>
+        <li>Model switching — choose between available Gemini model versions.</li>
+        <li>Runs entirely locally — your texts never leave your machine except for the AI API call.</li>
+      </ul>
+    </div>
+
+    <!-- Screenshots -->
+    <div class="about-card">
+      <h2>
+        <span class="icon">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><rect x="3" y="3" width="18" height="18" rx="2"/><circle cx="8.5" cy="8.5" r="1.5"/><polyline points="21 15 16 10 5 21"/></svg>
+        </span>
+        Screenshots
+      </h2>
+      <div class="screenshots-container screenshot-grid">
+        <div class="screenshot-item">
+          <img src="/static/screenshots/sources.png" alt="Sources page" onerror="this.closest('.screenshot-item').style.display='none'">
+          <div class="screenshot-caption">Sources page — manage your text sources and see detection statistics at a glance</div>
+        </div>
+        <div class="screenshot-item">
+          <img src="/static/screenshots/viewer.png" alt="Text viewer" onerror="this.closest('.screenshot-item').style.display='none'">
+          <div class="screenshot-caption">Text viewer — color-coded annotations with side-by-side verse references</div>
+        </div>
+        <div class="screenshot-item">
+          <img src="/static/screenshots/dashboard.png" alt="Analytics dashboard" onerror="this.closest('.screenshot-item').style.display='none'">
+          <div class="screenshot-caption">Analytics dashboard — explore scripture distribution across all sources</div>
+        </div>
+        <div class="screenshot-item">
+          <img src="/static/screenshots/settings.png" alt="Settings page" onerror="this.closest('.screenshot-item').style.display='none'">
+          <div class="screenshot-caption">Settings — configure your Gemini API key and model selection</div>
+        </div>
+      </div>
+    </div>
+
+  </div>
+
+  <!-- Footer -->
+  <div style="text-align:center;padding:40px 0 24px;color:var(--muted);font-size:.8rem;border-top:1px solid var(--border-light);margin-top:40px">
+    Developed by Dr. William J.B. Mattingly · Yale University · 2026<br>
+    Built for the <a href="https://www.oeaw.ac.at/en/imafo/events/event-details/ruse-of-reuse" target="_blank" style="color:var(--primary-mid)">Ruse of Reuse</a> workshop, Austrian Academy of Sciences, Vienna · March 5–6, 2026
+  </div>
+</div>
+
+</body>
+</html>

templates/dashboard.html

@@ -0,0 +1,277 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Scripture Detector — Dashboard</title>
+<link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+<link rel="stylesheet" href="/static/style.css">
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4"></script>
+<style>
+  .container { max-width: 1400px; }
+
+  .kpi-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: 16px; margin-bottom: 28px; }
+  .kpi {
+    background: var(--surface);
+    border-radius: var(--radius-lg);
+    padding: 24px;
+    box-shadow: var(--shadow-sm);
+    border: 1px solid var(--border-light);
+    text-align: center;
+    transition: var(--transition);
+  }
+  .kpi:hover { box-shadow: var(--shadow-md); transform: translateY(-2px); }
+  .kpi .val { font-size: 2.4rem; font-weight: 900; line-height: 1.1; letter-spacing: -.02em; }
+  .kpi .lbl { font-size: .7rem; color: var(--muted); text-transform: uppercase;
+    letter-spacing: .06em; margin-top: 8px; font-weight: 600; }
+  .kpi-primary .val { color: var(--primary); }
+  .kpi-green .val { color: var(--green); }
+  .kpi-accent .val { color: var(--accent); }
+  .kpi-purple .val { color: var(--allusion); }
+
+  .cards-row { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; margin-bottom: 28px; }
+  @media (max-width: 800px) { .cards-row { grid-template-columns: 1fr; } }
+
+  .chart-wrap { position: relative; width: 100%; height: 280px; }
+
+  .type-bar { height: 36px; border-radius: var(--radius-sm); margin-bottom: 12px; }
+  .type-bar div { display: flex; align-items: center; justify-content: center;
+    font-size: .72rem; font-weight: 700; color: #fff; min-width: 28px; transition: width .4s; }
+
+  .section-title { font-size: .9rem; font-weight: 700; margin-bottom: 16px;
+    text-transform: uppercase; letter-spacing: .06em; color: var(--muted); }
+
+  table { width: 100%; border-collapse: collapse; font-size: .84rem; }
+  th { text-align: left; padding: 12px 14px; border-bottom: 2px solid var(--border);
+    font-size: .7rem; text-transform: uppercase; letter-spacing: .06em; color: var(--muted);
+    cursor: pointer; user-select: none; white-space: nowrap; font-weight: 700; }
+  th:hover { color: var(--text); }
+  td { padding: 12px 14px; border-bottom: 1px solid var(--border-light); }
+  tr:hover td { background: var(--bg); }
+  .num { text-align: right; font-variant-numeric: tabular-nums; }
+  .link-cell a { color: var(--primary); text-decoration: none; font-weight: 600; }
+  .link-cell a:hover { text-decoration: underline; }
+  .mini-bar { display: flex; height: 18px; border-radius: 4px; overflow: hidden; min-width: 80px;
+    background: var(--bg-secondary); }
+  .mini-bar div { min-width: 2px; }
+</style>
+</head>
+<body>
+
+<div class="header">
+  <a href="/" class="header-brand">
+    <img src="/static/logo.svg" alt="Logo" class="header-logo">
+    <div>
+      <div class="header-title">Scripture Detector</div>
+      <div class="header-subtitle">Analytics Dashboard</div>
+    </div>
+  </a>
+  <nav>
+    <a href="/">Sources</a>
+    <a href="/dashboard" class="active">Dashboard</a>
+    <a href="/about">About</a>
+    <a href="/settings">Settings</a>
+  </nav>
+</div>
+
+<div class="container" id="app">
+  <div class="loading"><div class="spinner"></div>Loading dashboard data...</div>
+</div>
+
+<script>
+const app = document.getElementById('app');
+let RAW = null;
+let sortCol = 'name', sortAsc = true;
+
+function esc(s) { const d = document.createElement('div'); d.textContent = s; return d.innerHTML; }
+
+function render() {
+  if (!RAW) return;
+  const {source_count, quote_count, reference_count, sources, book_distribution, type_distribution} = RAW;
+
+  if (source_count === 0) {
+    app.innerHTML = `<div class="empty-state">
+      <img src="/static/logo.svg" alt="" class="empty-icon">
+      <h2>No data yet</h2>
+      <p>Add sources and process them to see analytics here.</p>
+      <a href="/" class="btn btn-primary">Go to Sources</a>
+    </div>`;
+    return;
+  }
+
+  const tc = type_distribution || {};
+  const totalTypes = Object.values(tc).reduce((s,v) => s + v, 0);
+  const pct = v => totalTypes ? ((v / totalTypes) * 100).toFixed(1) : 0;
+
+  let sorted = [...(sources || [])];
+  sorted.sort((x, y) => {
+    let va = x[sortCol] ?? '', vb = y[sortCol] ?? '';
+    if (typeof va === 'string') { va = va.toLowerCase(); vb = vb.toLowerCase(); }
+    return sortAsc ? (va < vb ? -1 : va > vb ? 1 : 0) : (va > vb ? -1 : va < vb ? 1 : 0);
+  });
+  const arrow = col => col === sortCol ? (sortAsc ? ' &#9650;' : ' &#9660;') : '';
+
+  const bd = book_distribution || [];
+  const topBook = bd.length > 0 ? (bd[0].book_name || bd[0].book_code) : '—';
+
+  app.innerHTML = `
+    <div class="kpi-grid">
+      <div class="kpi kpi-primary"><div class="val">${source_count}</div><div class="lbl">Sources</div></div>
+      <div class="kpi kpi-green"><div class="val">${quote_count}</div><div class="lbl">Quotes Found</div></div>
+      <div class="kpi kpi-accent"><div class="val">${reference_count}</div><div class="lbl">Scripture References</div></div>
+      <div class="kpi"><div class="val">${bd.length}</div><div class="lbl">Books Referenced</div></div>
+      <div class="kpi kpi-purple"><div class="val" style="font-size:1.4rem">${esc(topBook)}</div><div class="lbl">Most Referenced</div></div>
+    </div>
+
+    <div class="cards-row">
+      <div class="card">
+        <h3>Quote Type Distribution</h3>
+        ${totalTypes > 0 ? `
+        <div class="type-bar">
+          ${tc.full ? `<div style="width:${pct(tc.full)}%;background:var(--full)">${tc.full}</div>` : ''}
+          ${tc.partial ? `<div style="width:${pct(tc.partial)}%;background:var(--partial)">${tc.partial}</div>` : ''}
+          ${tc.paraphrase ? `<div style="width:${pct(tc.paraphrase)}%;background:var(--paraphrase)">${tc.paraphrase}</div>` : ''}
+          ${tc.allusion ? `<div style="width:${pct(tc.allusion)}%;background:var(--allusion)">${tc.allusion}</div>` : ''}
+        </div>
+        <div class="type-legend">
+          <div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--full)"></div>Full (${tc.full||0})</div>
+          <div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--partial)"></div>Partial (${tc.partial||0})</div>
+          <div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--paraphrase)"></div>Paraphrase (${tc.paraphrase||0})</div>
+          <div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--allusion)"></div>Allusion (${tc.allusion||0})</div>
+        </div>` : '<p style="color:var(--muted);font-size:.85rem">No quotes detected yet.</p>'}
+      </div>
+      <div class="card">
+        <h3>Top Bible Books Referenced</h3>
+        <div class="chart-wrap"><canvas id="book-chart"></canvas></div>
+      </div>
+    </div>
+
+    <div class="cards-row">
+      <div class="card">
+        <h3>Scripture Distribution by Testament</h3>
+        <div class="chart-wrap"><canvas id="testament-chart"></canvas></div>
+      </div>
+      <div class="card">
+        <h3>Quotes per Source</h3>
+        <div class="chart-wrap"><canvas id="source-chart"></canvas></div>
+      </div>
+    </div>
+
+    <div class="section-title">Per-Source Breakdown</div>
+    <div class="card" style="overflow-x:auto">
+      <table>
+        <thead><tr>
+          <th data-col="name">Source${arrow('name')}</th>
+          <th data-col="quote_count" class="num">Quotes${arrow('quote_count')}</th>
+          <th>Type Breakdown</th>
+          <th>Top Books</th>
+          <th data-col="created_at">Added${arrow('created_at')}</th>
+          <th></th>
+        </tr></thead>
+        <tbody>
+          ${sorted.map(s => {
+            const td = s.type_distribution || {};
+            const total = (td.full||0) + (td.partial||0) + (td.paraphrase||0) + (td.allusion||0);
+            const p = v => total ? ((v/total)*100).toFixed(0) : 0;
+            const sbd = s.book_distribution || [];
+            const topBooks = sbd.slice(0,3).map(b => b.book_name || b.book_code).join(', ');
+            return `<tr>
+              <td><strong>${esc(s.name)}</strong></td>
+              <td class="num">${s.quote_count}</td>
+              <td>${total > 0 ? `<div class="mini-bar">
+                ${td.full?`<div style="width:${p(td.full)}%;background:var(--full)"></div>`:''}
+                ${td.partial?`<div style="width:${p(td.partial)}%;background:var(--partial)"></div>`:''}
+                ${td.paraphrase?`<div style="width:${p(td.paraphrase)}%;background:var(--paraphrase)"></div>`:''}
+                ${td.allusion?`<div style="width:${p(td.allusion)}%;background:var(--allusion)"></div>`:''}
+              </div>` : '<span style="color:var(--muted);font-size:.78rem">—</span>'}</td>
+              <td style="font-size:.78rem;color:var(--muted)">${topBooks || '—'}</td>
+              <td style="font-size:.78rem;color:var(--muted)">${new Date(s.created_at).toLocaleDateString()}</td>
+              <td class="link-cell"><a href="/viewer/${s.id}">View</a></td>
+            </tr>`;
+          }).join('')}
+        </tbody>
+      </table>
+    </div>`;
+
+  document.querySelectorAll('th[data-col]').forEach(th => {
+    th.addEventListener('click', () => {
+      const col = th.dataset.col;
+      if (sortCol === col) sortAsc = !sortAsc;
+      else { sortCol = col; sortAsc = col === 'name'; }
+      render();
+    });
+  });
+
+  renderCharts(bd, sources);
+}
+
+function renderCharts(bookDist, sources) {
+  const chartFont = { family: "'Inter', system-ui, sans-serif" };
+
+  const bookCanvas = document.getElementById('book-chart');
+  if (bookCanvas && bookDist.length > 0) {
+    const top = bookDist.slice(0, 15);
+    const colors = top.map(d => d.testament === 'nt' ? '#6366f1' : d.testament === 'ot' ? '#f59e0b' : '#9ca3af');
+    new Chart(bookCanvas, {
+      type: 'bar',
+      data: {
+        labels: top.map(d => d.book_name || d.book_code),
+        datasets: [{ data: top.map(d => d.count), backgroundColor: colors, borderRadius: 6 }],
+      },
+      options: {
+        indexAxis: 'y', responsive: true, maintainAspectRatio: false,
+        plugins: { legend: { display: false } },
+        scales: {
+          x: { beginAtZero: true, ticks: { precision: 0, font: chartFont }, grid: { color: '#f0ede7' } },
+          y: { ticks: { font: { ...chartFont, size: 11 } }, grid: { display: false } },
+        },
+      },
+    });
+  }
+
+  const testCanvas = document.getElementById('testament-chart');
+  if (testCanvas && bookDist.length > 0) {
+    const tally = {ot: 0, nt: 0, ap: 0};
+    bookDist.forEach(d => { tally[d.testament] = (tally[d.testament] || 0) + d.count; });
+    const labels = []; const data = []; const colors = [];
+    if (tally.ot) { labels.push('Old Testament'); data.push(tally.ot); colors.push('#f59e0b'); }
+    if (tally.nt) { labels.push('New Testament'); data.push(tally.nt); colors.push('#6366f1'); }
+    if (tally.ap) { labels.push('Apocrypha'); data.push(tally.ap); colors.push('#9ca3af'); }
+    new Chart(testCanvas, {
+      type: 'doughnut',
+      data: { labels, datasets: [{ data, backgroundColor: colors, borderWidth: 3, borderColor: '#fff', hoverOffset: 8 }] },
+      options: {
+        responsive: true, maintainAspectRatio: false, cutout: '60%',
+        plugins: { legend: { position: 'bottom', labels: { padding: 20, font: { ...chartFont, size: 12 }, usePointStyle: true, pointStyle: 'rectRounded' } } },
+      },
+    });
+  }
+
+  const srcCanvas = document.getElementById('source-chart');
+  if (srcCanvas && sources.length > 0) {
+    const sorted = [...sources].sort((a,b) => b.quote_count - a.quote_count).slice(0, 15);
+    new Chart(srcCanvas, {
+      type: 'bar',
+      data: {
+        labels: sorted.map(s => s.name.length > 25 ? s.name.slice(0,22) + '...' : s.name),
+        datasets: [{ data: sorted.map(s => s.quote_count), backgroundColor: '#8b5cf6', borderRadius: 6 }],
+      },
+      options: {
+        indexAxis: 'y', responsive: true, maintainAspectRatio: false,
+        plugins: { legend: { display: false } },
+        scales: {
+          x: { beginAtZero: true, ticks: { precision: 0, font: chartFont }, grid: { color: '#f0ede7' } },
+          y: { ticks: { font: { ...chartFont, size: 11 } }, grid: { display: false } },
+        },
+      },
+    });
+  }
+}
+
+fetch('/api/dashboard')
+  .then(r => r.json())
+  .then(data => { RAW = data; render(); });
+</script>
+</body>
+</html>

templates/settings.html

@@ -0,0 +1,189 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Scripture Detector — Settings</title>
+<link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+<link rel="stylesheet" href="/static/style.css">
+<style>
+  .container { max-width: 640px; }
+
+  .card { margin-bottom: 20px; }
+
+  .radio-group { display: flex; gap: 12px; margin-bottom: 18px; }
+  .radio-card {
+    flex: 1;
+    padding: 18px;
+    border: 2px solid var(--border);
+    border-radius: var(--radius);
+    cursor: pointer;
+    transition: var(--transition);
+    text-align: center;
+    background: var(--surface);
+  }
+  .radio-card:hover { border-color: #a5b4fc; background: var(--primary-subtle); }
+  .radio-card.selected { border-color: var(--primary); background: var(--primary-subtle); }
+  .radio-card input { display: none; }
+  .radio-card .rc-title { font-size: .9rem; font-weight: 700; margin-bottom: 3px; color: var(--text); }
+  .radio-card .rc-desc { font-size: .74rem; color: var(--muted); }
+
+  .conditional { display: none; }
+  .conditional.visible { display: block; }
+
+  .actions { display: flex; gap: 12px; justify-content: flex-end; margin-top: 28px; align-items: center; }
+
+  .status-badge { display: inline-block; padding: 3px 10px; border-radius: 20px;
+    font-size: .76rem; font-weight: 600; }
+  .status-ok { background: rgba(22,163,74,.12); color: var(--green); }
+  .status-warn { background: rgba(245,158,11,.12); color: #92400e; }
+
+  .btn-success { background: linear-gradient(135deg, #16a34a, #15803d); color: #fff; }
+</style>
+</head>
+<body>
+
+<div class="header">
+  <a href="/" class="header-brand">
+    <img src="/static/logo.svg" alt="Logo" class="header-logo">
+    <div>
+      <div class="header-title">Scripture Detector</div>
+      <div class="header-subtitle">Settings</div>
+    </div>
+  </a>
+  <nav>
+    <a href="/">Sources</a>
+    <a href="/dashboard">Dashboard</a>
+    <a href="/about">About</a>
+    <a href="/settings" class="active">Settings</a>
+  </nav>
+</div>
+
+<div class="container">
+  <div class="card">
+    <h2>API Configuration</h2>
+
+    <label style="font-size:.82rem;font-weight:600;margin-bottom:10px;display:block;color:var(--text-secondary)">API Provider</label>
+    <div class="radio-group">
+      <label class="radio-card" id="rc-gemini" onclick="selectProvider('gemini')">
+        <input type="radio" name="provider" value="gemini">
+        <div class="rc-title">Gemini API</div>
+        <div class="rc-desc">Google AI Studio API Key</div>
+      </label>
+      <label class="radio-card" id="rc-vertex" onclick="selectProvider('vertex')">
+        <input type="radio" name="provider" value="vertex">
+        <div class="rc-title">Vertex AI</div>
+        <div class="rc-desc">Google Cloud Project</div>
+      </label>
+    </div>
+
+    <div class="conditional" id="gemini-fields">
+      <div class="field">
+        <label for="api-key">API Key</label>
+        <input type="password" id="api-key" placeholder="AIza...">
+        <div class="hint">Get your key from <a href="https://aistudio.google.com/apikey" target="_blank">Google AI Studio</a></div>
+      </div>
+    </div>
+
+    <div class="conditional" id="vertex-fields">
+      <div class="field">
+        <label for="project-id">Project ID</label>
+        <input type="text" id="project-id" placeholder="my-gcp-project">
+      </div>
+      <div class="field">
+        <label for="location">Location</label>
+        <input type="text" id="location" placeholder="global" value="global">
+        <div class="hint">e.g. global, us-central1, europe-west1</div>
+      </div>
+    </div>
+  </div>
+
+  <div class="card">
+    <h2>Model Selection</h2>
+    <div class="field">
+      <label for="model-select">Model</label>
+      <select id="model-select">
+        {% for m in models %}
+        <option value="{{ m.id }}">{{ m.name }}</option>
+        {% endfor %}
+      </select>
+    </div>
+  </div>
+
+  <div class="actions">
+    <span id="save-status"></span>
+    <button class="btn btn-primary" id="save-btn" onclick="saveSettings()">Save Settings</button>
+  </div>
+</div>
+
+<script>
+let currentProvider = 'gemini';
+
+function showToast(msg, ok) {
+  const el = document.createElement('div');
+  el.className = 'toast ' + (ok ? 'toast-ok' : 'toast-err');
+  el.textContent = msg;
+  document.body.appendChild(el);
+  setTimeout(() => { el.style.opacity = '0'; setTimeout(() => el.remove(), 400); }, 3500);
+}
+
+function selectProvider(p) {
+  currentProvider = p;
+  document.getElementById('rc-gemini').classList.toggle('selected', p === 'gemini');
+  document.getElementById('rc-vertex').classList.toggle('selected', p === 'vertex');
+  document.getElementById('gemini-fields').classList.toggle('visible', p === 'gemini');
+  document.getElementById('vertex-fields').classList.toggle('visible', p === 'vertex');
+}
+
+function loadSettings() {
+  fetch('/api/settings')
+    .then(r => r.json())
+    .then(s => {
+      const provider = s.api_provider || 'gemini';
+      selectProvider(provider);
+      if (s.gemini_api_key) document.getElementById('api-key').value = s.gemini_api_key;
+      if (s.vertex_project_id) document.getElementById('project-id').value = s.vertex_project_id;
+      if (s.vertex_location) document.getElementById('location').value = s.vertex_location;
+      if (s.model) document.getElementById('model-select').value = s.model;
+    });
+}
+
+function saveSettings() {
+  const btn = document.getElementById('save-btn');
+  btn.disabled = true;
+  const payload = {
+    api_provider: currentProvider,
+    model: document.getElementById('model-select').value,
+  };
+  if (currentProvider === 'gemini') {
+    const key = document.getElementById('api-key').value.trim();
+    if (key) payload.gemini_api_key = key;
+  } else {
+    payload.vertex_project_id = document.getElementById('project-id').value.trim();
+    payload.vertex_location = document.getElementById('location').value.trim() || 'global';
+  }
+  fetch('/api/settings', {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify(payload),
+  })
+  .then(r => r.json())
+  .then(() => {
+    showToast('Settings saved!', true);
+    btn.classList.remove('btn-primary');
+    btn.classList.add('btn-success');
+    btn.textContent = 'Saved!';
+    setTimeout(() => {
+      btn.classList.remove('btn-success');
+      btn.classList.add('btn-primary');
+      btn.textContent = 'Save Settings';
+    }, 2000);
+  })
+  .catch(e => showToast('Error: ' + e.message, false))
+  .finally(() => { btn.disabled = false; });
+}
+
+loadSettings();
+</script>
+</body>
+</html>

templates/sources.html

@@ -0,0 +1,1031 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Scripture Detector</title>
+<link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+<link rel="stylesheet" href="/static/style.css">
+<style>
+/* ── Toolbar ────────────────────────────────────────────────────────── */
+.toolbar {
+  display: flex; gap: 12px; margin-bottom: 16px;
+  align-items: center; flex-wrap: wrap;
+}
+.toolbar .summary {
+  font-size: .84rem; color: var(--muted); margin-left: auto;
+}
+.toolbar .summary strong { color: var(--text); font-weight: 700; }
+
+/* ── Search Panel ───────────────────────────────────────────────────── */
+.search-panel {
+  background: var(--surface);
+  border: 1.5px solid var(--border);
+  border-radius: var(--radius-lg);
+  padding: 16px 20px;
+  margin-bottom: 24px;
+  box-shadow: var(--shadow-sm);
+}
+
+.search-top { display: flex; gap: 10px; align-items: center; }
+
+.search-input-wrap { flex: 1; position: relative; }
+.search-input-wrap svg {
+  position: absolute; left: 11px; top: 50%;
+  transform: translateY(-50%); color: var(--muted); pointer-events: none;
+}
+.search-input {
+  width: 100%; padding: 9px 14px 9px 38px;
+  border: 1.5px solid var(--border); border-radius: var(--radius-sm);
+  font-size: .9rem; font-family: inherit; color: var(--text);
+  transition: var(--transition);
+}
+.search-input:focus {
+  outline: none; border-color: var(--primary-mid);
+  box-shadow: 0 0 0 3px var(--primary-subtle);
+}
+.search-input.has-value { border-color: var(--primary-mid); }
+
+.search-clear {
+  position: absolute; right: 10px; top: 50%; transform: translateY(-50%);
+  background: none; border: none; cursor: pointer; color: var(--muted);
+  font-size: 1rem; line-height: 1; padding: 2px 4px; border-radius: 3px;
+  display: none;
+}
+.search-clear:hover { color: var(--red); }
+
+.adv-toggle {
+  display: flex; align-items: center; gap: 7px;
+  padding: 8px 16px; border: 1.5px solid var(--border);
+  border-radius: var(--radius-sm); background: var(--surface);
+  cursor: pointer; font-size: .84rem; font-weight: 600;
+  color: var(--muted); white-space: nowrap; font-family: inherit;
+  transition: var(--transition);
+}
+.adv-toggle:hover { border-color: var(--primary-mid); color: var(--primary); }
+.adv-toggle.active {
+  border-color: var(--primary); color: var(--primary);
+  background: var(--primary-pale);
+}
+.adv-toggle .badge {
+  background: var(--primary); color: #fff;
+  border-radius: 10px; font-size: .68rem; font-weight: 800;
+  padding: 1px 6px; display: none;
+}
+.adv-toggle.has-filters .badge { display: inline; }
+
+/* ── Advanced Panel ─────────────────────────────────────────────────── */
+.adv-panel {
+  margin-top: 14px; padding-top: 14px;
+  border-top: 1px solid var(--border-light);
+  display: none;
+}
+.adv-panel.visible { display: block; }
+
+.adv-header {
+  display: flex; align-items: center; gap: 14px;
+  margin-bottom: 12px; flex-wrap: wrap;
+}
+.adv-header label {
+  font-size: .78rem; font-weight: 700;
+  color: var(--muted); text-transform: uppercase; letter-spacing: .06em;
+}
+
+/* Logic toggle pill */
+.logic-toggle {
+  display: inline-flex; border: 1.5px solid var(--border);
+  border-radius: var(--radius-sm); overflow: hidden;
+}
+.logic-btn {
+  padding: 5px 14px; border: none; background: transparent;
+  cursor: pointer; font-size: .8rem; font-weight: 700;
+  color: var(--muted); font-family: inherit; transition: var(--transition);
+}
+.logic-btn.active { background: var(--primary); color: #fff; }
+
+/* Filter rows */
+.filter-rows { display: flex; flex-direction: column; gap: 8px; }
+
+.filter-row {
+  display: flex; align-items: center; gap: 8px; flex-wrap: wrap;
+  padding: 10px 14px;
+  background: var(--bg); border-radius: var(--radius-sm);
+  border: 1px solid var(--border-light);
+  position: relative;
+}
+
+.filter-connector {
+  font-size: .7rem; font-weight: 800; color: var(--primary);
+  text-transform: uppercase; letter-spacing: .08em;
+  min-width: 28px; text-align: center;
+}
+
+.filter-select, .filter-input {
+  padding: 6px 10px; border: 1.5px solid var(--border);
+  border-radius: var(--radius-sm); font-size: .84rem;
+  font-family: inherit; color: var(--text); background: var(--surface);
+  transition: var(--transition);
+}
+.filter-select:focus, .filter-input:focus {
+  outline: none; border-color: var(--primary-mid);
+  box-shadow: 0 0 0 3px var(--primary-subtle);
+}
+.filter-select:disabled { opacity: .4; }
+.filter-type { min-width: 130px; }
+.filter-book { min-width: 150px; }
+.filter-chapter { width: 80px; }
+.filter-verse { width: 80px; }
+.filter-text { flex: 1; min-width: 160px; }
+
+.filter-remove {
+  background: none; border: none; cursor: pointer;
+  color: var(--muted); font-size: 1.1rem; line-height: 1;
+  padding: 2px 6px; border-radius: 4px; margin-left: auto;
+  transition: var(--transition);
+}
+.filter-remove:hover { color: var(--red); background: rgba(198,40,40,.08); }
+
+.add-filter-btn {
+  display: inline-flex; align-items: center; gap: 5px;
+  margin-top: 8px; padding: 7px 14px;
+  border: 1.5px dashed var(--border); border-radius: var(--radius-sm);
+  background: transparent; cursor: pointer; font-size: .82rem;
+  font-weight: 600; color: var(--muted); font-family: inherit;
+  transition: var(--transition);
+}
+.add-filter-btn:hover {
+  border-color: var(--primary-mid); color: var(--primary);
+  background: var(--primary-subtle);
+}
+
+/* Active filters summary chip strip */
+.active-chips {
+  display: flex; gap: 6px; flex-wrap: wrap; margin-top: 10px;
+}
+.chip {
+  display: inline-flex; align-items: center; gap: 5px;
+  background: var(--primary-pale); color: var(--primary);
+  border: 1px solid #c9dcf5; border-radius: 20px;
+  font-size: .76rem; font-weight: 600; padding: 3px 10px;
+}
+.chip .chip-x {
+  background: none; border: none; cursor: pointer;
+  color: var(--primary-mid); font-size: .9rem; line-height: 1;
+  padding: 0; margin-left: 1px;
+}
+.chip .chip-x:hover { color: var(--red); }
+
+/* ── Source Grid ────────────────────────────────────────────────────── */
+.source-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(360px, 1fr));
+  gap: 20px;
+}
+
+.source-card {
+  background: var(--surface);
+  border-radius: var(--radius-lg);
+  box-shadow: var(--shadow-sm);
+  border: 1.5px solid var(--border-light);
+  padding: 24px;
+  transition: all .22s cubic-bezier(.4,0,.2,1);
+  display: flex; flex-direction: column; gap: 14px; cursor: pointer;
+}
+.source-card:hover {
+  box-shadow: var(--shadow-lg); transform: translateY(-3px);
+  border-color: var(--primary-light);
+}
+.source-card.search-match { border-color: #c9dcf5; }
+
+.sc-header { display: flex; align-items: flex-start; gap: 12px; }
+.sc-name { font-size: 1.05rem; font-weight: 700; flex: 1; line-height: 1.35; }
+.sc-date {
+  font-size: .7rem; color: var(--muted); white-space: nowrap;
+  background: var(--bg-secondary); padding: 3px 8px; border-radius: 4px;
+}
+.sc-stats { display: flex; gap: 24px; }
+.sc-stat { display: flex; flex-direction: column; }
+.sc-stat-val { font-size: 1.4rem; font-weight: 800; }
+.sc-stat-lbl {
+  font-size: .66rem; color: var(--muted); text-transform: uppercase;
+  letter-spacing: .06em; font-weight: 600;
+}
+.sc-stat-primary .sc-stat-val { color: var(--primary); }
+.sc-stat-accent .sc-stat-val { color: var(--accent); }
+
+.sc-books {
+  font-size: .78rem; color: var(--muted); line-height: 1.5;
+  padding: 8px 12px; background: var(--bg); border-radius: var(--radius-sm);
+}
+
+.sc-footer {
+  display: flex; gap: 8px; align-items: center;
+  margin-top: auto; padding-top: 8px;
+  border-top: 1px solid var(--border-light);
+}
+
+/* ── Match Evidence ─────────────────────────────────────────────────── */
+.match-evidence {
+  border-radius: var(--radius-sm);
+  overflow: hidden;
+  border: 1px solid #c9dcf5;
+}
+.match-evidence-header {
+  font-size: .7rem; font-weight: 700; text-transform: uppercase;
+  letter-spacing: .06em; color: var(--primary);
+  padding: 5px 10px; background: var(--primary-pale);
+  display: flex; align-items: center; gap: 5px;
+}
+.match-item {
+  padding: 8px 10px; font-size: .8rem; border-top: 1px solid #dce8f8;
+  background: var(--surface);
+}
+.match-item:first-child { border-top: none; }
+
+.match-text-snippet {
+  color: var(--text-secondary); line-height: 1.6;
+}
+.match-text-snippet mark {
+  background: #fef08a; color: #713f12;
+  border-radius: 2px; padding: 1px 3px; font-weight: 800;
+  box-shadow: 0 0 0 1px #fde047;
+}
+.match-loc {
+  font-size: .68rem; color: var(--muted); margin-top: 3px;
+  font-style: italic;
+}
+
+.match-ref-row {
+  display: flex; align-items: flex-start; gap: 7px; flex-wrap: wrap;
+}
+.match-ref-badge {
+  font-family: 'SF Mono', ui-monospace, monospace;
+  font-size: .72rem; font-weight: 700;
+  background: var(--bg-secondary); color: var(--primary);
+  padding: 2px 7px; border-radius: 4px; white-space: nowrap;
+  border: 1px solid var(--border-light);
+}
+.match-ref-quote {
+  color: var(--muted); font-style: italic;
+  flex: 1; min-width: 0; overflow: hidden;
+  white-space: nowrap; text-overflow: ellipsis;
+}
+
+.no-results {
+  grid-column: 1/-1; text-align: center;
+  padding: 60px 20px; color: var(--muted);
+}
+.no-results h3 { font-size: 1.1rem; color: var(--text); margin-bottom: 8px; }
+.no-results p { font-size: .9rem; }
+
+.results-info {
+  font-size: .82rem; color: var(--muted); margin-bottom: 16px;
+  display: flex; align-items: center; gap: 8px;
+}
+.results-info strong { color: var(--text); }
+.results-info .clear-link {
+  color: var(--primary-mid); cursor: pointer; text-decoration: underline;
+  font-size: .8rem; margin-left: 4px;
+}
+
+/* searching state */
+.search-panel.searching .search-input { border-color: var(--primary-mid); }
+</style>
+</head>
+<body>
+
+<div class="header">
+  <a href="/" class="header-brand">
+    <img src="/static/logo.svg" alt="Logo" class="header-logo">
+    <div>
+      <div class="header-title">Scripture Detector</div>
+      <div class="header-subtitle">Scriptural Quote Detection &amp; Analysis</div>
+    </div>
+  </a>
+  <nav>
+    <a href="/" class="active">Sources</a>
+    <a href="/dashboard">Dashboard</a>
+    <a href="/about">About</a>
+    <a href="/settings">Settings</a>
+  </nav>
+</div>
+
+<div class="container">
+
+  <!-- Toolbar -->
+  <div class="toolbar" id="toolbar">
+    <button class="btn btn-primary" onclick="openModal()">
+      <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+      Add Source
+    </button>
+    <button class="btn btn-ghost" onclick="importZip()" title="Import sources from a ZIP archive exported by Scripture Detector">
+      <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="17 8 12 3 7 8"/><line x1="12" y1="3" x2="12" y2="15"/></svg>
+      Import ZIP
+    </button>
+    <a class="btn btn-ghost" id="export-zip-btn" href="/api/export/zip" download
+       title="Export all sources as TEI XML inside a ZIP archive">
+      <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
+      Export ZIP
+    </a>
+    <!-- hidden file input for ZIP import -->
+    <input type="file" id="zip-file-input" accept=".zip" style="display:none" onchange="handleZipUpload(this)">
+    <div class="summary" id="summary-line"></div>
+  </div>
+
+  <!-- Search panel -->
+  <div class="search-panel" id="search-panel">
+    <div class="search-top">
+      <!-- Simple text search -->
+      <div class="search-input-wrap">
+        <svg width="15" height="15" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
+        <input id="text-search" class="search-input" type="text"
+               placeholder="Search source text content…" autocomplete="off"
+               oninput="onTextInput()" onkeydown="if(event.key==='Escape')clearText()">
+        <button class="search-clear" id="text-clear" onclick="clearText()" title="Clear">×</button>
+      </div>
+      <!-- Advanced toggle -->
+      <button class="adv-toggle" id="adv-toggle" onclick="toggleAdv()">
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2"><line x1="4" y1="6" x2="20" y2="6"/><line x1="8" y1="12" x2="16" y2="12"/><line x1="11" y1="18" x2="13" y2="18"/></svg>
+        Advanced
+        <span class="badge" id="adv-badge">0</span>
+      </button>
+    </div>
+
+    <!-- Advanced filter builder -->
+    <div class="adv-panel" id="adv-panel">
+      <div class="adv-header">
+        <label>Combine filters with:</label>
+        <div class="logic-toggle">
+          <button class="logic-btn active" id="logic-and" onclick="setLogic('AND')">AND</button>
+          <button class="logic-btn" id="logic-or" onclick="setLogic('OR')">OR</button>
+        </div>
+        <span style="font-size:.78rem;color:var(--muted)" id="logic-desc">
+          Source must match <strong>all</strong> filters
+        </span>
+      </div>
+      <div class="filter-rows" id="filter-rows"></div>
+      <button class="add-filter-btn" onclick="addFilterRow()">
+        <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+        Add Filter
+      </button>
+    </div>
+  </div>
+
+  <!-- Active filter chips (shown when filters are active) -->
+  <div class="active-chips" id="active-chips"></div>
+
+  <!-- Results info bar (shown during search) -->
+  <div class="results-info" id="results-info" style="display:none"></div>
+
+  <!-- Source grid -->
+  <div id="source-grid-wrap">
+    <div style="text-align:center;padding:60px;color:var(--muted)">
+      <div class="spinner" style="margin:0 auto 12px"></div>Loading…
+    </div>
+  </div>
+
+</div>
+
+<!-- Add source modal -->
+<div class="modal-overlay" id="add-modal">
+  <div class="modal">
+    <h2>Add New Source</h2>
+    <label for="src-name">Source Name</label>
+    <input type="text" id="src-name" placeholder="e.g. Augustine, Confessions Book I">
+    <label for="src-text">Text</label>
+    <textarea id="src-text" placeholder="Paste the text to analyze here…"></textarea>
+    <div class="actions">
+      <button class="btn btn-ghost" onclick="closeModal()">Cancel</button>
+      <button class="btn btn-primary" id="save-src-btn" onclick="saveSource()">Add Source</button>
+    </div>
+  </div>
+</div>
+
+<script>
+// ── State ────────────────────────────────────────────────────────────────────
+let RAW = null;           // full dashboard data
+let bibleBooks = null;    // [{code, name, testament}]
+let advOpen = false;
+let currentLogic = 'AND';
+let filterIdSeq = 0;
+let filters = [];         // [{id, type, value, book, chapter}]
+let searchTimer = null;
+let isSearching = false;
+
+// ── Utilities ────────────────────────────────────────────────────────────────
+function esc(s) { const d = document.createElement('div'); d.textContent = s; return d.innerHTML; }
+function showToast(msg, ok) {
+  const el = document.createElement('div');
+  el.className = 'toast ' + (ok ? 'toast-ok' : 'toast-err');
+  el.textContent = msg;
+  document.body.appendChild(el);
+  setTimeout(() => { el.style.opacity = '0'; setTimeout(() => el.remove(), 400); }, 3500);
+}
+
+// ── Modal ────────────────────────────────────────────────────────────────────
+const addModal = document.getElementById('add-modal');
+function openModal() { addModal.classList.add('active'); document.getElementById('src-name').focus(); }
+function closeModal() { addModal.classList.remove('active'); }
+
+function saveSource() {
+  const name = document.getElementById('src-name').value.trim();
+  const text = document.getElementById('src-text').value.trim();
+  if (!name || !text) { showToast('Name and text are required', false); return; }
+  const btn = document.getElementById('save-src-btn');
+  btn.disabled = true; btn.textContent = 'Saving…';
+  fetch('/api/sources', {
+    method: 'POST', headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({name, text}),
+  })
+  .then(r => r.json())
+  .then(data => {
+    if (data.error) { showToast(data.error, false); return; }
+    closeModal();
+    document.getElementById('src-name').value = '';
+    document.getElementById('src-text').value = '';
+    showToast('Source added!', true);
+    loadAll();
+  })
+  .catch(e => showToast('Error: ' + e.message, false))
+  .finally(() => { btn.disabled = false; btn.textContent = 'Add Source'; });
+}
+
+function deleteSource(e, id, name) {
+  e.stopPropagation();
+  if (!confirm(`Delete "${name}" and all its quotes?`)) return;
+  fetch(`/api/sources/${id}`, {method: 'DELETE'})
+    .then(() => { showToast('Source deleted', true); loadAll(); })
+    .catch(e => showToast('Error: ' + e.message, false));
+}
+
+// ── Text search ──────────────────────────────────────────────────────────────
+function onTextInput() {
+  const val = document.getElementById('text-search').value;
+  document.getElementById('text-clear').style.display = val ? 'block' : 'none';
+  document.getElementById('text-search').classList.toggle('has-value', !!val);
+  scheduleSearch();
+}
+function clearText() {
+  document.getElementById('text-search').value = '';
+  document.getElementById('text-clear').style.display = 'none';
+  document.getElementById('text-search').classList.remove('has-value');
+  scheduleSearch();
+}
+
+// ── Advanced toggle ──────────────────────────────────────────────────────────
+function toggleAdv() {
+  advOpen = !advOpen;
+  document.getElementById('adv-panel').classList.toggle('visible', advOpen);
+  document.getElementById('adv-toggle').classList.toggle('active', advOpen);
+}
+
+function setLogic(l) {
+  currentLogic = l;
+  document.getElementById('logic-and').classList.toggle('active', l === 'AND');
+  document.getElementById('logic-or').classList.toggle('active',  l === 'OR');
+  document.getElementById('logic-desc').innerHTML =
+    l === 'AND'
+      ? 'Source must match <strong>all</strong> filters'
+      : 'Source must match <strong>any</strong> filter';
+  renderFilterRows();   // update connector labels between rows
+  scheduleSearch();
+}
+
+// ── Filter rows ──────────────────────────────────────────────────────────────
+function loadBibleBooks() {
+  if (bibleBooks) return Promise.resolve();
+  return fetch('/api/bible/books').then(r => r.json()).then(books => {
+    bibleBooks = books;
+  });
+}
+
+function addFilterRow(preset) {
+  loadBibleBooks().then(() => {
+    const id = ++filterIdSeq;
+    const type = preset?.type || 'book';
+    filters.push({ id, type, value: preset?.value || '', book: '', chapter: '' });
+    renderFilterRows();
+    // If preset, update UI after render
+    if (preset) applyPreset(id, preset);
+    scheduleSearch();
+  });
+}
+
+function applyPreset(id, preset) {
+  const row = document.querySelector(`.filter-row[data-id="${id}"]`);
+  if (!row) return;
+  if (preset.book) {
+    const bSel = row.querySelector('.filter-book');
+    if (bSel) { bSel.value = preset.book; onBookChange(id); }
+  }
+}
+
+function removeFilterRow(id) {
+  filters = filters.filter(f => f.id !== id);
+  renderFilterRows();
+  updateAdvBadge();
+  scheduleSearch();
+}
+
+function renderFilterRows() {
+  const container = document.getElementById('filter-rows');
+  container.innerHTML = '';
+
+  filters.forEach((f, idx) => {
+    const row = document.createElement('div');
+    row.className = 'filter-row';
+    row.dataset.id = f.id;
+
+    // connector
+    if (idx > 0) {
+      const conn = document.createElement('span');
+      conn.className = 'filter-connector';
+      conn.textContent = currentLogic;
+      row.appendChild(conn);
+    }
+
+    // type selector
+    const typeSel = document.createElement('select');
+    typeSel.className = 'filter-select filter-type';
+    [
+      ['book',    'Bible Book'],
+      ['chapter', 'Chapter'],
+      ['verse',   'Verse'],
+      ['text',    'Text Content'],
+    ].forEach(([val, label]) => {
+      const opt = document.createElement('option');
+      opt.value = val; opt.textContent = label;
+      if (val === f.type) opt.selected = true;
+      typeSel.appendChild(opt);
+    });
+    typeSel.addEventListener('change', () => {
+      const fi = filters.find(x => x.id === f.id);
+      if (fi) { fi.type = typeSel.value; fi.book = ''; fi.chapter = ''; fi.value = ''; }
+      renderFilterRows();
+      scheduleSearch();
+    });
+    row.appendChild(typeSel);
+
+    if (f.type === 'text') {
+      // text input
+      const inp = document.createElement('input');
+      inp.type = 'text'; inp.className = 'filter-select filter-text';
+      inp.placeholder = 'Search text…'; inp.value = f.value;
+      inp.addEventListener('input', () => {
+        const fi = filters.find(x => x.id === f.id);
+        if (fi) fi.value = inp.value;
+        scheduleSearch();
+      });
+      row.appendChild(inp);
+    } else {
+      // book dropdown
+      const bookSel = document.createElement('select');
+      bookSel.className = 'filter-select filter-book';
+      const defOpt = document.createElement('option');
+      defOpt.value = ''; defOpt.textContent = 'Select book…';
+      bookSel.appendChild(defOpt);
+      (bibleBooks || []).forEach(b => {
+        const opt = document.createElement('option');
+        opt.value = b.code;
+        opt.textContent = b.name;
+        if (b.code === f.book) opt.selected = true;
+        bookSel.appendChild(opt);
+      });
+      bookSel.addEventListener('change', () => {
+        const fi = filters.find(x => x.id === f.id);
+        if (fi) { fi.book = bookSel.value; fi.chapter = ''; fi.value = fi.book; }
+        onBookChange(f.id);
+        scheduleSearch();
+      });
+      row.appendChild(bookSel);
+
+      if (f.type === 'chapter' || f.type === 'verse') {
+        // chapter dropdown
+        const chSel = document.createElement('select');
+        chSel.className = 'filter-select filter-chapter';
+        chSel.disabled = !f.book;
+        const chDef = document.createElement('option');
+        chDef.value = ''; chDef.textContent = 'Ch.';
+        chSel.appendChild(chDef);
+        chSel.dataset.book = f.book;
+        chSel.addEventListener('change', () => {
+          const fi = filters.find(x => x.id === f.id);
+          if (fi) {
+            fi.chapter = chSel.value;
+            fi.value = fi.chapter ? `${fi.book}_${fi.chapter}` : fi.book;
+          }
+          if (f.type === 'verse') onChapterChange(f.id);
+          scheduleSearch();
+        });
+        row.appendChild(chSel);
+        row.dataset.chSel = true;
+
+        // load chapters if book already selected
+        if (f.book) {
+          fetch(`/api/bible/${f.book}/chapters`).then(r => r.json()).then(chs => {
+            chs.forEach(ch => {
+              const opt = document.createElement('option');
+              opt.value = ch; opt.textContent = ch;
+              if (String(ch) === String(f.chapter)) opt.selected = true;
+              chSel.appendChild(opt);
+            });
+            chSel.disabled = false;
+          });
+        }
+
+        if (f.type === 'verse') {
+          // verse number input
+          const vInp = document.createElement('input');
+          vInp.type = 'number'; vInp.min = '1';
+          vInp.className = 'filter-select filter-verse';
+          vInp.placeholder = 'Verse #';
+          vInp.disabled = !f.chapter;
+          if (f.verse) vInp.value = f.verse;
+          vInp.addEventListener('input', () => {
+            const fi = filters.find(x => x.id === f.id);
+            if (fi) {
+              fi.verse = vInp.value;
+              fi.value = fi.chapter && vInp.value
+                ? `${fi.book}_${fi.chapter}:${vInp.value}`
+                : (fi.chapter ? `${fi.book}_${fi.chapter}` : fi.book);
+            }
+            scheduleSearch();
+          });
+          row.appendChild(vInp);
+        }
+      }
+    }
+
+    // remove button
+    const rem = document.createElement('button');
+    rem.className = 'filter-remove'; rem.title = 'Remove filter';
+    rem.innerHTML = '&times;';
+    rem.onclick = () => removeFilterRow(f.id);
+    row.appendChild(rem);
+    container.appendChild(row);
+  });
+
+  updateAdvBadge();
+  renderChips();
+}
+
+function onBookChange(fid) {
+  const fi = filters.find(x => x.id === fid);
+  if (!fi) return;
+  fi.chapter = ''; fi.verse = '';
+  fi.value = fi.book;
+  const row = document.querySelector(`.filter-row[data-id="${fid}"]`);
+  if (!row) return;
+  const chSel = row.querySelector('.filter-chapter');
+  const vInp  = row.querySelector('.filter-verse');
+  if (chSel) {
+    chSel.innerHTML = '<option value="">Ch.</option>';
+    chSel.disabled = !fi.book;
+    if (fi.book) {
+      fetch(`/api/bible/${fi.book}/chapters`).then(r => r.json()).then(chs => {
+        chs.forEach(ch => {
+          const opt = document.createElement('option');
+          opt.value = ch; opt.textContent = ch;
+          chSel.appendChild(opt);
+        });
+      });
+    }
+  }
+  if (vInp) { vInp.value = ''; vInp.disabled = true; }
+}
+
+function onChapterChange(fid) {
+  const fi = filters.find(x => x.id === fid);
+  if (!fi) return;
+  const row = document.querySelector(`.filter-row[data-id="${fid}"]`);
+  if (!row) return;
+  const vInp = row.querySelector('.filter-verse');
+  if (vInp) { vInp.value = ''; vInp.disabled = !fi.chapter; }
+}
+
+function updateAdvBadge() {
+  const active = filters.filter(f => f.value).length;
+  const badge = document.getElementById('adv-badge');
+  badge.textContent = active;
+  document.getElementById('adv-toggle').classList.toggle('has-filters', active > 0);
+}
+
+// ── Chip strip (active filter summary) ──────────────────────────────────────
+function renderChips() {
+  const container = document.getElementById('active-chips');
+  const textVal = document.getElementById('text-search').value.trim();
+  const activeFilters = filters.filter(f => f.value);
+  container.innerHTML = '';
+
+  if (textVal) {
+    const chip = makeChip(`Text: "${textVal}"`, clearText);
+    container.appendChild(chip);
+  }
+  activeFilters.forEach(f => {
+    let label = '';
+    if (f.type === 'book') label = `Book: ${bookName(f.book)}`;
+    else if (f.type === 'chapter') label = `Chapter: ${bookName(f.book)} ${f.chapter}`;
+    else if (f.type === 'verse') label = `Verse: ${f.value}`;
+    else if (f.type === 'text') label = `Text: "${f.value}"`;
+    if (label) {
+      const chip = makeChip(label, () => removeFilterRow(f.id));
+      container.appendChild(chip);
+    }
+  });
+}
+
+function makeChip(label, onRemove) {
+  const chip = document.createElement('span');
+  chip.className = 'chip';
+  chip.innerHTML = `${esc(label)} <button class="chip-x" title="Remove">&times;</button>`;
+  chip.querySelector('.chip-x').onclick = onRemove;
+  return chip;
+}
+
+function bookName(code) {
+  if (!bibleBooks) return code;
+  const b = bibleBooks.find(x => x.code === code);
+  return b ? b.name : code;
+}
+
+// ── Search scheduling ────────────────────────────────────────────────────────
+function scheduleSearch() {
+  clearTimeout(searchTimer);
+  renderChips();
+  searchTimer = setTimeout(executeSearch, 320);
+}
+
+function executeSearch() {
+  const textVal = document.getElementById('text-search').value.trim();
+  const structFilters = filters.filter(f => f.value.trim());
+
+  // If nothing active, show all sources from RAW
+  if (!textVal && structFilters.length === 0) {
+    renderSources(null);
+    return;
+  }
+
+  const allFilters = [];
+  if (textVal) allFilters.push({ type: 'text', value: textVal });
+  structFilters.forEach(f => allFilters.push({ type: f.type, value: f.value }));
+
+  isSearching = true;
+  document.getElementById('search-panel').classList.add('searching');
+
+  fetch('/api/search', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ filters: allFilters, logic: currentLogic }),
+  })
+  .then(r => r.json())
+  .then(data => {
+    isSearching = false;
+    document.getElementById('search-panel').classList.remove('searching');
+    renderSources(data);
+  })
+  .catch(e => {
+    isSearching = false;
+    document.getElementById('search-panel').classList.remove('searching');
+    showToast('Search error: ' + e.message, false);
+  });
+}
+
+// ── Rendering ──��─────────────────────────────────────────────────────────────
+function renderSources(searchResult) {
+  const wrap = document.getElementById('source-grid-wrap');
+  const infoBar = document.getElementById('results-info');
+
+  // Determine what to show
+  let sources, isFiltered, totalCount;
+  if (searchResult === null) {
+    // Show all from dashboard
+    if (!RAW) return;
+    sources = RAW.sources.map(s => ({
+      ...s,
+      type_distribution: s.type_distribution || {},
+      book_distribution: s.book_distribution || [],
+      match_evidence: null,
+    }));
+    isFiltered = false;
+    totalCount = RAW.source_count;
+
+    infoBar.style.display = 'none';
+    document.getElementById('summary-line').innerHTML =
+      `<strong>${RAW.source_count}</strong> source${RAW.source_count !== 1 ? 's' : ''}
+       &nbsp;&middot;&nbsp;
+       <strong>${RAW.quote_count}</strong> quote${RAW.quote_count !== 1 ? 's' : ''}
+       &nbsp;&middot;&nbsp;
+       <strong>${RAW.reference_count}</strong> reference${RAW.reference_count !== 1 ? 's' : ''}`;
+  } else {
+    sources = searchResult.results;
+    isFiltered = true;
+    totalCount = RAW ? RAW.source_count : '?';
+
+    const n = searchResult.total;
+    infoBar.style.display = 'flex';
+    infoBar.innerHTML = `
+      Showing <strong>${n}</strong> of <strong>${totalCount}</strong> source${totalCount !== 1 ? 's' : ''}
+      matching your ${currentLogic === 'AND' ? 'AND' : 'OR'} filters
+      <span class="clear-link" onclick="clearAllFilters()">Clear all filters</span>`;
+    document.getElementById('summary-line').innerHTML =
+      `<strong>${n}</strong> result${n !== 1 ? 's' : ''}`;
+  }
+
+  // Empty state
+  if (sources.length === 0 && !isFiltered) {
+    wrap.innerHTML = `
+      <div class="empty-state">
+        <img src="/static/logo.svg" alt="" class="empty-icon">
+        <h2>No sources yet</h2>
+        <p>Add a text source to get started with scripture detection and analysis.</p>
+        <button class="btn btn-primary btn-lg" onclick="openModal()">
+          <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+          Add Your First Source
+        </button>
+      </div>`;
+    return;
+  }
+
+  const grid = document.createElement('div');
+  grid.className = 'source-grid';
+
+  if (isFiltered && sources.length === 0) {
+    grid.innerHTML = `
+      <div class="no-results">
+        <h3>No matching sources</h3>
+        <p>Try adjusting your filters or switching from AND to OR logic.</p>
+      </div>`;
+    wrap.innerHTML = ''; wrap.appendChild(grid); return;
+  }
+
+  sources.forEach(s => {
+    const td = s.type_distribution || {};
+    const bd = s.book_distribution || [];
+    const total = (td.full||0) + (td.partial||0) + (td.paraphrase||0) + (td.allusion||0);
+    const p = v => total ? ((v / total) * 100).toFixed(0) : 0;
+    const topBooks = bd.slice(0, 4).map(b => b.book_name || b.book_code);
+    const booksText = topBooks.length > 0
+      ? topBooks.join(', ') + (bd.length > 4 ? ` +${bd.length - 4} more` : '')
+      : 'No books referenced yet';
+
+    const card = document.createElement('div');
+    card.className = 'source-card' + (isFiltered ? ' search-match' : '');
+    card.onclick = () => window.location.href = '/viewer/' + s.id;
+
+    // Match evidence HTML
+    let evidenceHtml = '';
+    if (s.match_evidence && s.match_evidence.length > 0) {
+      const items = s.match_evidence.map(ev => {
+        if (ev.kind === 'text') {
+          if (ev.offset < 0) {
+            // Name-only match
+            return `<div class="match-item">
+              <div class="match-text-snippet">
+                Matched source name: <mark>${esc(ev.query)}</mark>
+              </div>
+            </div>`;
+          }
+          const hl = highlightMatch(ev.snippet, ev.query);
+          const pos = ev.offset > 0 ? `~${Math.round(ev.offset / 100) * 100} chars in` : 'start of text';
+          return `<div class="match-item">
+            <div class="match-text-snippet">${hl}</div>
+            <div class="match-loc">Found at ${pos}</div>
+          </div>`;
+        } else {
+          const qt = `<span class="type-badge type-${esc(ev.quote_type)}">${esc(ev.quote_type)}</span>`;
+          return `<div class="match-item">
+            <div class="match-ref-row">
+              <span class="match-ref-badge">${esc(ev.reference)}</span>
+              ${qt}
+              <span class="match-ref-quote">"${esc(ev.quote_text)}"</span>
+            </div>
+          </div>`;
+        }
+      }).join('');
+      evidenceHtml = `
+        <div class="match-evidence">
+          <div class="match-evidence-header">
+            <svg width="11" height="11" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
+            Match Evidence
+          </div>
+          ${items}
+        </div>`;
+    }
+
+    card.innerHTML = `
+      <div class="sc-header">
+        <div class="sc-name">${esc(s.name)}</div>
+        <div class="sc-date">${new Date(s.created_at).toLocaleDateString()}</div>
+      </div>
+      <div class="sc-stats">
+        <div class="sc-stat sc-stat-primary">
+          <div class="sc-stat-val">${s.quote_count}</div>
+          <div class="sc-stat-lbl">Quotes</div>
+        </div>
+        <div class="sc-stat sc-stat-accent">
+          <div class="sc-stat-val">${bd.length}</div>
+          <div class="sc-stat-lbl">Books</div>
+        </div>
+      </div>
+      ${total > 0 ? `
+      <div>
+        <div class="type-bar">
+          ${td.full      ? `<div style="width:${p(td.full)}%;background:var(--full)"></div>` : ''}
+          ${td.partial   ? `<div style="width:${p(td.partial)}%;background:var(--partial)"></div>` : ''}
+          ${td.paraphrase? `<div style="width:${p(td.paraphrase)}%;background:var(--paraphrase)"></div>` : ''}
+          ${td.allusion  ? `<div style="width:${p(td.allusion)}%;background:var(--allusion)"></div>` : ''}
+        </div>
+        <div class="type-legend">
+          ${td.full      ? `<div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--full)"></div>${td.full} Full</div>` : ''}
+          ${td.partial   ? `<div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--partial)"></div>${td.partial} Partial</div>` : ''}
+          ${td.paraphrase? `<div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--paraphrase)"></div>${td.paraphrase} Paraphrase</div>` : ''}
+          ${td.allusion  ? `<div class="type-legend-item"><div class="type-legend-swatch" style="background:var(--allusion)"></div>${td.allusion} Allusion</div>` : ''}
+        </div>
+      </div>` : '<div style="font-size:.78rem;color:var(--muted);font-style:italic">Not yet processed</div>'}
+      ${evidenceHtml || `<div class="sc-books">${esc(booksText)}</div>`}
+      <div class="sc-footer">
+        <button class="btn btn-primary btn-sm"
+                onclick="event.stopPropagation();window.location.href='/viewer/${s.id}'">
+          View
+          <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round"><line x1="5" y1="12" x2="19" y2="12"/><polyline points="12 5 19 12 12 19"/></svg>
+        </button>
+        <div style="flex:1"></div>
+        <button class="btn btn-ghost btn-sm" style="color:var(--red)"
+                onclick="deleteSource(event,${s.id},'${esc(s.name).replace(/'/g,"\\'")}')">Delete</button>
+      </div>`;
+    grid.appendChild(card);
+  });
+
+  wrap.innerHTML = ''; wrap.appendChild(grid);
+}
+
+function highlightMatch(snippet, query) {
+  if (!query) return esc(snippet);
+  // esc() the snippet first, then highlight the query within the escaped HTML
+  const escaped = esc(snippet);
+  const qEsc = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // The query arrives lowercased from the API; match case-insensitively
+  return escaped.replace(new RegExp(qEsc, 'gi'), m => `<mark>${m}</mark>`);
+}
+
+function clearAllFilters() {
+  clearText();
+  filters = [];
+  renderFilterRows();
+  if (advOpen) {
+    document.getElementById('adv-panel').classList.remove('visible');
+    document.getElementById('adv-toggle').classList.remove('active');
+    advOpen = false;
+  }
+  renderSources(null);
+  document.getElementById('active-chips').innerHTML = '';
+  document.getElementById('results-info').style.display = 'none';
+}
+
+// ── ZIP Import ───────────────────────────────────────────────────────────────
+function importZip() {
+  document.getElementById('zip-file-input').click();
+}
+
+function handleZipUpload(input) {
+  const file = input.files[0];
+  if (!file) return;
+  input.value = '';   // reset so same file can be re-selected
+
+  const formData = new FormData();
+  formData.append('file', file);
+
+  // Show a toast while importing
+  const prog = document.createElement('div');
+  prog.className = 'toast toast-ok';
+  prog.style.opacity = '1';
+  prog.textContent = `Importing ${file.name}…`;
+  document.body.appendChild(prog);
+
+  fetch('/api/import/zip', { method: 'POST', body: formData })
+    .then(r => r.json())
+    .then(data => {
+      prog.remove();
+      if (data.error) { showToast(data.error, false); return; }
+      const errMsg = data.errors && data.errors.length
+        ? `  (${data.errors.length} file${data.errors.length !== 1 ? 's' : ''} failed)`
+        : '';
+      showToast(`Imported ${data.imported} source${data.imported !== 1 ? 's' : ''}${errMsg}`, true);
+      loadAll();
+    })
+    .catch(e => { prog.remove(); showToast('Import error: ' + e.message, false); });
+}
+
+// ── Initial load ────────────────────���────────────────────────────────────────
+function loadAll() {
+  // /api/dashboard already includes per-source type_distribution & book_distribution
+  fetch('/api/dashboard')
+    .then(r => r.json())
+    .then(data => { RAW = data; renderSources(null); });
+}
+
+addModal.addEventListener('click', e => { if (e.target === addModal) closeModal(); });
+loadAll();
+</script>
+</body>
+</html>

templates/viewer.html

@@ -0,0 +1,865 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>Scripture Detector — {{ source.name }}</title>
+<link rel="icon" type="image/svg+xml" href="/static/favicon.svg">
+<link rel="stylesheet" href="/static/style.css">
+<script src="https://cdn.jsdelivr.net/npm/chart.js@4"></script>
+<style>
+  .header { position: sticky; top: 0; }
+
+  .action-bar {
+    display: flex;
+    gap: 10px;
+    padding: 12px 24px;
+    background: var(--surface);
+    border-bottom: 1px solid var(--border-light);
+    align-items: center;
+    flex-wrap: wrap;
+  }
+
+  .select-styled {
+    padding: 7px 12px;
+    border-radius: var(--radius-sm);
+    border: 1.5px solid var(--border);
+    background: var(--surface);
+    font-size: .82rem;
+    color: var(--text);
+    font-family: inherit;
+    transition: var(--transition);
+  }
+  .select-styled:focus {
+    outline: none;
+    border-color: var(--primary);
+    box-shadow: 0 0 0 3px var(--primary-subtle);
+  }
+
+  .tabs {
+    display: flex;
+    border-bottom: 2px solid var(--border-light);
+    padding: 0 24px;
+    background: var(--surface);
+  }
+  .tab {
+    padding: 12px 22px;
+    font-size: .84rem;
+    font-weight: 600;
+    color: var(--muted);
+    cursor: pointer;
+    border-bottom: 2px solid transparent;
+    margin-bottom: -2px;
+    transition: var(--transition);
+    user-select: none;
+  }
+  .tab:hover { color: var(--text); }
+  .tab.active { color: var(--primary); border-bottom-color: var(--primary); }
+
+  .tab-content { display: none; }
+  .tab-content.active { display: block; }
+
+  .main { display: grid; grid-template-columns: 1fr 400px; height: calc(100vh - 160px); }
+  @media (max-width: 900px) { .main { grid-template-columns: 1fr; } }
+
+  .text-panel {
+    padding: 32px 36px;
+    overflow-y: auto;
+    line-height: 1.9;
+    font-family: 'Palatino Linotype', 'Book Antiqua', Palatino, Georgia, serif;
+    font-size: 1.02rem;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    background: var(--surface);
+  }
+
+  .seg-full { background: var(--full-bg); border-bottom: 2px solid var(--full);
+    cursor: pointer; transition: all .15s; border-radius: 2px; padding: 0 1px; }
+  .seg-partial { background: var(--partial-bg); border-bottom: 2px solid var(--partial);
+    cursor: pointer; transition: all .15s; border-radius: 2px; padding: 0 1px; }
+  .seg-paraphrase { background: var(--paraphrase-bg); border-bottom: 2px solid var(--paraphrase);
+    cursor: pointer; transition: all .15s; border-radius: 2px; padding: 0 1px; }
+  .seg-allusion { background: var(--allusion-bg); border-bottom: 2px solid var(--allusion);
+    cursor: pointer; transition: all .15s; border-radius: 2px; padding: 0 1px; }
+  .seg-multi { background: rgba(99,102,241,.12); border-bottom: 2px solid var(--primary);
+    cursor: pointer; transition: all .15s; border-radius: 2px; padding: 0 1px; }
+  [class^="seg-"]:hover { filter: brightness(.92); }
+  .seg-active { outline: 2px solid var(--primary); outline-offset: 2px; border-radius: 3px; }
+
+  .ann-panel {
+    background: var(--bg);
+    border-left: 1px solid var(--border-light);
+    overflow-y: auto;
+    padding: 20px;
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+  }
+  .ann-panel h2 {
+    font-size: .78rem;
+    text-transform: uppercase;
+    letter-spacing: .08em;
+    color: var(--muted);
+    margin: 8px 0 4px;
+    font-weight: 700;
+  }
+  .ann-card {
+    background: var(--surface);
+    border-radius: var(--radius);
+    border-left: 4px solid var(--border);
+    padding: 14px 16px;
+    font-size: .83rem;
+    box-shadow: var(--shadow-sm);
+    cursor: pointer;
+    transition: all .15s;
+    position: relative;
+    border: 1px solid var(--border-light);
+  }
+  .ann-card:hover { box-shadow: var(--shadow-md); }
+  .ann-card.active { box-shadow: 0 0 0 2px var(--primary); }
+  .ann-full { border-left: 4px solid var(--full) !important; }
+  .ann-partial { border-left: 4px solid var(--partial) !important; }
+  .ann-paraphrase { border-left: 4px solid var(--paraphrase) !important; }
+  .ann-allusion { border-left: 4px solid var(--allusion) !important; }
+
+  .ann-refs { display: flex; flex-wrap: wrap; gap: 5px; margin-bottom: 8px; }
+  .ref-badge {
+    display: inline-block;
+    padding: 2px 8px;
+    border-radius: 5px;
+    font-size: .72rem;
+    font-weight: 600;
+    font-family: 'SF Mono', 'Fira Code', ui-monospace, monospace;
+    background: var(--bg-secondary);
+    color: var(--text-secondary);
+    border: 1px solid var(--border-light);
+  }
+
+  .ann-quote {
+    color: var(--muted);
+    font-style: italic;
+    margin-bottom: 8px;
+    max-height: 3.6em;
+    overflow: hidden;
+    line-height: 1.2em;
+    font-size: .8rem;
+  }
+  .ann-verse { border-top: 1px solid var(--border-light); padding-top: 8px; margin-top: 6px; font-size: .78rem; }
+  .ann-verse strong {
+    color: var(--text-secondary);
+    font-family: 'SF Mono', 'Fira Code', ui-monospace, monospace;
+    font-size: .72rem;
+  }
+  .ann-verse .vtext { color: var(--muted); }
+  .ann-actions { display: flex; gap: 6px; margin-top: 10px; }
+
+  /* Distribution tab */
+  .dist-content { max-width: 1000px; margin: 0 auto; padding: 28px; }
+  .dist-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
+  @media (max-width: 800px) { .dist-grid { grid-template-columns: 1fr; } }
+  .dist-card {
+    background: var(--surface);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-sm);
+    border: 1px solid var(--border-light);
+    padding: 24px;
+  }
+  .dist-card h3 {
+    font-size: .8rem;
+    font-weight: 700;
+    margin-bottom: 16px;
+    text-transform: uppercase;
+    letter-spacing: .06em;
+    color: var(--muted);
+  }
+  .chart-wrap { position: relative; width: 100%; height: 300px; }
+
+  /* Selection toolbar */
+  .sel-toolbar {
+    position: fixed;
+    z-index: 200;
+    background: var(--surface);
+    border-radius: var(--radius);
+    box-shadow: var(--shadow-xl);
+    padding: 8px;
+    display: none;
+    gap: 6px;
+    border: 1px solid var(--border-light);
+  }
+  .sel-toolbar.visible { display: flex; }
+
+  /* Reference tags */
+  .ref-tags { display: flex; flex-wrap: wrap; gap: 6px; min-height: 28px; padding: 6px 0; }
+  .ref-tag {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    padding: 4px 10px;
+    background: var(--primary-light);
+    color: #3730a3;
+    border-radius: 6px;
+    font-size: .78rem;
+    font-weight: 600;
+    font-family: 'SF Mono', 'Fira Code', ui-monospace, monospace;
+  }
+  .ref-tag button {
+    background: none;
+    border: none;
+    cursor: pointer;
+    color: #6366f1;
+    font-size: .9rem;
+    line-height: 1;
+    padding: 0 2px;
+  }
+  .ref-tag button:hover { color: var(--red); }
+
+  /* Reference picker */
+  .ref-picker {
+    border: 1.5px solid var(--border);
+    border-radius: var(--radius);
+    padding: 14px;
+    margin-top: 10px;
+    background: var(--bg);
+  }
+  .ref-picker-row { display: flex; gap: 8px; margin-bottom: 10px; }
+  .ref-picker-row select {
+    flex: 1;
+    padding: 8px 12px;
+    border-radius: var(--radius-sm);
+    border: 1.5px solid var(--border);
+    font-size: .84rem;
+    background: var(--surface);
+    font-family: inherit;
+  }
+  .ref-picker-row select:disabled { opacity: .4; }
+  .ref-verses {
+    max-height: 220px;
+    overflow-y: auto;
+    border: 1px solid var(--border-light);
+    border-radius: var(--radius-sm);
+    background: var(--surface);
+  }
+  .ref-verse-item {
+    display: flex;
+    gap: 8px;
+    padding: 8px 12px;
+    font-size: .82rem;
+    cursor: pointer;
+    transition: background .1s;
+    align-items: flex-start;
+    border-bottom: 1px solid var(--border-light);
+  }
+  .ref-verse-item:last-child { border-bottom: none; }
+  .ref-verse-item:hover { background: var(--primary-subtle); }
+  .ref-verse-item.added { background: rgba(22,163,74,.06); }
+  .ref-verse-num {
+    font-weight: 700;
+    color: var(--primary);
+    min-width: 24px;
+    font-family: 'SF Mono', 'Fira Code', ui-monospace, monospace;
+    font-size: .78rem;
+    padding-top: 1px;
+  }
+  .ref-verse-text { color: var(--muted); flex: 1; line-height: 1.4; font-size: .8rem; }
+  .ref-verse-add {
+    font-size: .7rem;
+    font-weight: 700;
+    color: var(--green);
+    white-space: nowrap;
+    padding-top: 1px;
+  }
+  .ref-verse-item.added .ref-verse-add { color: var(--muted); }
+  .ref-no-verses { padding: 20px; text-align: center; color: var(--muted); font-size: .84rem; }
+
+  .legend-bar {
+    display: flex;
+    gap: 16px;
+    font-size: .74rem;
+    color: var(--muted);
+    align-items: center;
+    flex-wrap: wrap;
+  }
+  .legend-item { display: flex; align-items: center; gap: 5px; }
+  .legend-swatch { width: 22px; height: 8px; border-radius: 4px; }
+</style>
+</head>
+<body>
+
+<div class="header">
+  <a href="/" class="header-brand">
+    <img src="/static/logo.svg" alt="Logo" class="header-logo">
+    <div>
+      <div class="header-title">Scripture Detector</div>
+      <div class="header-subtitle">{{ source.name }}</div>
+    </div>
+  </a>
+  <nav>
+    <a href="/">Sources</a>
+    <a href="/dashboard">Dashboard</a>
+    <a href="/about">About</a>
+    <a href="/settings">Settings</a>
+  </nav>
+</div>
+
+<div class="action-bar">
+  <button class="btn btn-primary" id="process-btn" onclick="processSource()">
+    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/></svg>
+    Process with AI
+  </button>
+  <a class="btn btn-ghost" id="export-tei-btn"
+     href="/api/sources/{{ source.id }}/export/tei" download
+     title="Download this source as TEI XML">
+    <svg width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round"><path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"/><polyline points="7 10 12 15 17 10"/><line x1="12" y1="15" x2="12" y2="3"/></svg>
+    Export TEI
+  </a>
+  <select class="select-styled" id="model-select">
+    {% for m in models %}
+    <option value="{{ m.id }}" {{ 'selected' if m.id == current_model else '' }}>{{ m.name }}</option>
+    {% endfor %}
+  </select>
+  <button class="btn btn-ghost" id="add-quote-btn" onclick="openAddModal()">
+    <svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+    Add Quote
+  </button>
+  <div style="margin-left:auto">
+    <div class="legend-bar">
+      <div class="legend-item"><div class="legend-swatch" style="background:var(--full-bg);border-bottom:2px solid var(--full)"></div>Full</div>
+      <div class="legend-item"><div class="legend-swatch" style="background:var(--partial-bg);border-bottom:2px solid var(--partial)"></div>Partial</div>
+      <div class="legend-item"><div class="legend-swatch" style="background:var(--paraphrase-bg);border-bottom:2px solid var(--paraphrase)"></div>Paraphrase</div>
+      <div class="legend-item"><div class="legend-swatch" style="background:var(--allusion-bg);border-bottom:2px solid var(--allusion)"></div>Allusion</div>
+    </div>
+  </div>
+</div>
+
+<div class="tabs">
+  <div class="tab active" data-tab="text">Text</div>
+  <div class="tab" data-tab="distribution">Distribution</div>
+</div>
+
+<div class="tab-content active" id="tab-text">
+  <div class="main">
+    <div class="text-panel" id="text-panel"><div class="loading"><div class="spinner"></div>Loading...</div></div>
+    <div class="ann-panel" id="ann-panel"></div>
+  </div>
+</div>
+
+<div class="tab-content" id="tab-distribution">
+  <div class="dist-content">
+    <div class="dist-grid">
+      <div class="dist-card">
+        <h3>Bible Books Referenced</h3>
+        <div class="chart-wrap"><canvas id="dist-book-chart"></canvas></div>
+      </div>
+      <div class="dist-card">
+        <h3>Quote Type Distribution</h3>
+        <div class="chart-wrap"><canvas id="dist-type-chart"></canvas></div>
+      </div>
+    </div>
+  </div>
+</div>
+
+<div class="sel-toolbar" id="sel-toolbar">
+  <button class="btn btn-primary btn-sm" onclick="analyzeSelection()">Analyze Selection</button>
+  <button class="btn btn-ghost btn-sm" onclick="addFromSelection()">Add as Quote</button>
+</div>
+
+<div class="modal-overlay" id="quote-modal">
+  <div class="modal">
+    <h2 id="modal-title">Add Quote</h2>
+    <input type="hidden" id="qm-id">
+    <label>Quote Text</label>
+    <textarea id="qm-text" rows="2" style="min-height:60px"></textarea>
+    <label>Quote Type</label>
+    <select id="qm-type">
+      <option value="full">Full</option>
+      <option value="partial">Partial</option>
+      <option value="paraphrase">Paraphrase</option>
+      <option value="allusion" selected>Allusion</option>
+    </select>
+    <label>References</label>
+    <div class="ref-tags" id="qm-ref-tags"></div>
+    <div class="ref-picker">
+      <div class="ref-picker-row">
+        <select id="ref-book" onchange="onBookChange()">
+          <option value="">Select Book...</option>
+        </select>
+        <select id="ref-chapter" disabled onchange="onChapterChange()">
+          <option value="">Ch.</option>
+        </select>
+      </div>
+      <div id="ref-verses-wrap" style="display:none">
+        <div class="ref-verses" id="ref-verses"></div>
+      </div>
+    </div>
+    <input type="hidden" id="qm-start">
+    <input type="hidden" id="qm-end">
+    <div class="actions">
+      <button class="btn btn-ghost" onclick="closeQuoteModal()">Cancel</button>
+      <button class="btn btn-primary" id="qm-save" onclick="saveQuote()">Save</button>
+    </div>
+  </div>
+</div>
+
+<script>
+const SOURCE_ID = {{ source.id }};
+const textPanel = document.getElementById('text-panel');
+const annPanel = document.getElementById('ann-panel');
+const selToolbar = document.getElementById('sel-toolbar');
+const quoteModal = document.getElementById('quote-modal');
+let DATA = null;
+let selRange = null;
+let distChartsRendered = false;
+let modalRefs = [];
+let bibleBooks = null;
+
+function esc(s) { const d = document.createElement('div'); d.textContent = s; return d.innerHTML; }
+function showToast(msg, ok) {
+  const el = document.createElement('div');
+  el.className = 'toast ' + (ok ? 'toast-ok' : 'toast-err');
+  el.textContent = msg;
+  document.body.appendChild(el);
+  setTimeout(() => { el.style.opacity = '0'; setTimeout(() => el.remove(), 400); }, 3500);
+}
+
+document.querySelectorAll('.tab').forEach(tab => {
+  tab.addEventListener('click', () => {
+    document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+    document.querySelectorAll('.tab-content').forEach(t => t.classList.remove('active'));
+    tab.classList.add('active');
+    document.getElementById('tab-' + tab.dataset.tab).classList.add('active');
+    if (tab.dataset.tab === 'distribution' && !distChartsRendered) loadDistribution();
+  });
+});
+
+document.getElementById('model-select').addEventListener('change', e => {
+  fetch('/api/settings', {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({model: e.target.value}),
+  });
+});
+
+function loadSource() {
+  textPanel.innerHTML = '<div class="loading"><div class="spinner"></div>Loading...</div>';
+  annPanel.innerHTML = '';
+  fetch(`/api/sources/${SOURCE_ID}`)
+    .then(r => r.json())
+    .then(data => { DATA = data; renderText(); });
+}
+
+function renderText() {
+  if (!DATA) return;
+  const {segments, annotations} = DATA;
+
+  let html = '';
+  segments.forEach((seg, i) => {
+    if (seg.annotation_ids.length === 0) {
+      html += `<span data-start="${seg.start}" data-end="${seg.end}">${esc(seg.text)}</span>`;
+    } else {
+      const types = new Set(seg.annotation_ids.map(id => annotations[id]?.quote_type));
+      let cls = 'seg-multi';
+      if (types.size === 1) cls = `seg-${[...types][0]}`;
+      const ids = seg.annotation_ids.join(',');
+      html += `<span class="${cls}" data-ann="${ids}" data-start="${seg.start}" data-end="${seg.end}">${esc(seg.text)}</span>`;
+    }
+  });
+  textPanel.innerHTML = html;
+
+  let annHtml = '<h2>Annotations (' + annotations.length + ')</h2>';
+  if (annotations.length === 0) {
+    annHtml += '<p style="color:var(--muted);font-size:.84rem;padding:16px 0">No quotes detected yet. Click "Process with AI" to analyze this text.</p>';
+  }
+  annotations.forEach((a, i) => {
+    const qt = a.quote_type || 'allusion';
+    const snippet = (a.quote_text || '').slice(0, 140);
+    let versesHtml = '';
+    (a.verses || []).forEach(v => {
+      const vt = v.text ? esc(v.text) : '<span style="color:var(--red);font-style:italic">not found</span>';
+      versesHtml += `<div class="ann-verse"><strong>${esc(v.ref)}</strong> <span class="vtext">${vt}</span></div>`;
+    });
+    annHtml += `
+      <div class="ann-card ann-${qt}" data-idx="${i}" data-id="${a.id}">
+        <div class="ann-refs">
+          <span class="type-badge type-${qt}">${qt}</span>
+          ${(a.refs||[]).map(r => `<span class="ref-badge">${esc(r)}</span>`).join('')}
+        </div>
+        <div class="ann-quote">"${esc(snippet)}${snippet.length < (a.quote_text||'').length ? '...' : ''}"</div>
+        ${versesHtml}
+        <div class="ann-actions">
+          <button class="btn btn-ghost btn-sm" onclick="event.stopPropagation();editQuote(${i})">Edit</button>
+          <button class="btn btn-ghost btn-sm" style="color:var(--red)" onclick="event.stopPropagation();deleteQuote(${a.id})">Delete</button>
+        </div>
+      </div>`;
+  });
+  annPanel.innerHTML = annHtml;
+  bindTextEvents();
+}
+
+function bindTextEvents() {
+  textPanel.querySelectorAll('[data-ann]').forEach(span => {
+    span.addEventListener('click', () => {
+      clearActive();
+      span.classList.add('seg-active');
+      span.dataset.ann.split(',').forEach(id => {
+        const card = annPanel.querySelector(`.ann-card[data-idx="${id}"]`);
+        if (card) { card.classList.add('active'); card.scrollIntoView({behavior:'smooth',block:'center'}); }
+      });
+    });
+  });
+  annPanel.querySelectorAll('.ann-card').forEach(card => {
+    card.addEventListener('click', () => {
+      clearActive();
+      card.classList.add('active');
+      const idx = card.dataset.idx;
+      textPanel.querySelectorAll('[data-ann]').forEach(span => {
+        if (span.dataset.ann.split(',').includes(idx)) {
+          span.classList.add('seg-active');
+          span.scrollIntoView({behavior:'smooth',block:'center'});
+        }
+      });
+    });
+  });
+}
+
+function clearActive() {
+  document.querySelectorAll('.seg-active').forEach(e => e.classList.remove('seg-active'));
+  document.querySelectorAll('.ann-card.active').forEach(e => e.classList.remove('active'));
+}
+
+function getCharPos(node, offset) {
+  let el = node.nodeType === Node.TEXT_NODE ? node.parentElement : node;
+  while (el && !el.dataset.start) el = el.parentElement;
+  if (!el) return null;
+  return parseInt(el.dataset.start) + Math.min(offset, (el.textContent || '').length);
+}
+
+textPanel.addEventListener('mouseup', () => {
+  setTimeout(() => {
+    const sel = window.getSelection();
+    if (!sel.rangeCount || sel.isCollapsed || sel.toString().trim().length < 3) {
+      selToolbar.classList.remove('visible'); selRange = null; return;
+    }
+    const range = sel.getRangeAt(0);
+    const s = getCharPos(range.startContainer, range.startOffset);
+    const e = getCharPos(range.endContainer, range.endOffset);
+    if (s === null || e === null || e <= s) {
+      selToolbar.classList.remove('visible'); selRange = null; return;
+    }
+    selRange = {start: Math.min(s,e), end: Math.max(s,e), text: sel.toString()};
+    const rect = range.getBoundingClientRect();
+    selToolbar.style.top = (rect.top - 44 + window.scrollY) + 'px';
+    selToolbar.style.left = (rect.left + rect.width/2 - 100) + 'px';
+    selToolbar.classList.add('visible');
+  }, 10);
+});
+
+document.addEventListener('mousedown', e => {
+  if (!selToolbar.contains(e.target)) selToolbar.classList.remove('visible');
+});
+
+const PROCESS_ICON = '<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/></svg>';
+
+function processSource() {
+  if (DATA && DATA.annotations && DATA.annotations.length > 0) {
+    const n = DATA.annotations.length;
+    if (!confirm(
+      `This source already has ${n} annotation${n !== 1 ? 's' : ''}.\n\n` +
+      `Processing with AI will delete all existing annotations and replace them with new results.\n\n` +
+      `This cannot be undone. Continue?`
+    )) return;
+  }
+  const btn = document.getElementById('process-btn');
+  btn.disabled = true;
+  btn.innerHTML = '<div class="spinner" style="width:14px;height:14px;border-width:2px;margin:0"></div> Processing...';
+  fetch(`/api/sources/${SOURCE_ID}/process`, {method: 'POST'})
+    .then(r => r.json())
+    .then(data => {
+      if (data.error) { showToast(data.error, false); return; }
+      showToast(`Found ${data.count} quotes`, true);
+      distChartsRendered = false;
+      loadSource();
+    })
+    .catch(e => showToast('Error: ' + e.message, false))
+    .finally(() => { btn.disabled = false; btn.innerHTML = PROCESS_ICON + ' Process with AI'; });
+}
+
+function analyzeSelection() {
+  if (!selRange) return;
+  if (DATA && DATA.annotations && DATA.annotations.length > 0) {
+    const n = DATA.annotations.length;
+    if (!confirm(
+      `This source already has ${n} annotation${n !== 1 ? 's' : ''}.\n\n` +
+      `Analyzing this selection may overwrite existing annotations that overlap the selected passage.\n\n` +
+      `Continue?`
+    )) return;
+  }
+  selToolbar.classList.remove('visible');
+  const btn = document.getElementById('process-btn');
+  btn.disabled = true;
+  btn.innerHTML = '<div class="spinner" style="width:14px;height:14px;border-width:2px;margin:0"></div> Analyzing selection...';
+  fetch(`/api/sources/${SOURCE_ID}/process-selection`, {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({start: selRange.start, end: selRange.end}),
+  })
+  .then(r => r.json())
+  .then(data => {
+    if (data.error) { showToast(data.error, false); return; }
+    showToast(`Found ${data.count} quotes in selection`, true);
+    distChartsRendered = false;
+    loadSource();
+  })
+  .catch(e => showToast('Error: ' + e.message, false))
+  .finally(() => { btn.disabled = false; btn.innerHTML = PROCESS_ICON + ' Process with AI'; selRange = null; });
+}
+
+function loadBibleBooks() {
+  if (bibleBooks) return Promise.resolve();
+  return fetch('/api/bible/books').then(r => r.json()).then(books => {
+    bibleBooks = books;
+    const sel = document.getElementById('ref-book');
+    sel.innerHTML = '<option value="">Select Book...</option>';
+    books.forEach(b => {
+      const opt = document.createElement('option');
+      opt.value = b.code;
+      opt.textContent = `${b.name} (${b.code})`;
+      sel.appendChild(opt);
+    });
+  });
+}
+
+function onBookChange() {
+  const book = document.getElementById('ref-book').value;
+  const chSel = document.getElementById('ref-chapter');
+  const versesWrap = document.getElementById('ref-verses-wrap');
+  chSel.innerHTML = '<option value="">Ch.</option>';
+  chSel.disabled = true;
+  versesWrap.style.display = 'none';
+  if (!book) return;
+  fetch(`/api/bible/${book}/chapters`).then(r => r.json()).then(chapters => {
+    chapters.forEach(ch => {
+      const opt = document.createElement('option');
+      opt.value = ch;
+      opt.textContent = ch;
+      chSel.appendChild(opt);
+    });
+    chSel.disabled = false;
+  });
+}
+
+function onChapterChange() {
+  const book = document.getElementById('ref-book').value;
+  const chapter = document.getElementById('ref-chapter').value;
+  const versesWrap = document.getElementById('ref-verses-wrap');
+  const versesList = document.getElementById('ref-verses');
+  versesWrap.style.display = 'none';
+  if (!book || !chapter) return;
+  fetch(`/api/bible/${book}/${chapter}/verses`).then(r => r.json()).then(verses => {
+    if (verses.length === 0) {
+      versesList.innerHTML = '<div class="ref-no-verses">No verses found</div>';
+    } else {
+      versesList.innerHTML = verses.map(v => {
+        const ref = `${book}_${chapter}:${v.verse}`;
+        const isAdded = modalRefs.includes(ref);
+        return `<div class="ref-verse-item${isAdded ? ' added' : ''}" data-ref="${esc(ref)}" onclick="toggleVerse(this,'${esc(ref)}')">
+          <div class="ref-verse-num">${v.verse}</div>
+          <div class="ref-verse-text">${esc(v.text)}</div>
+          <div class="ref-verse-add">${isAdded ? 'Added' : '+ Add'}</div>
+        </div>`;
+      }).join('');
+    }
+    versesWrap.style.display = 'block';
+  });
+}
+
+function toggleVerse(el, ref) {
+  const idx = modalRefs.indexOf(ref);
+  if (idx >= 0) {
+    modalRefs.splice(idx, 1);
+    el.classList.remove('added');
+    el.querySelector('.ref-verse-add').textContent = '+ Add';
+  } else {
+    modalRefs.push(ref);
+    el.classList.add('added');
+    el.querySelector('.ref-verse-add').textContent = 'Added';
+  }
+  renderRefTags();
+}
+
+function removeRef(ref) {
+  modalRefs = modalRefs.filter(r => r !== ref);
+  renderRefTags();
+  document.querySelectorAll(`.ref-verse-item[data-ref="${ref}"]`).forEach(el => {
+    el.classList.remove('added');
+    el.querySelector('.ref-verse-add').textContent = '+ Add';
+  });
+}
+
+function renderRefTags() {
+  const container = document.getElementById('qm-ref-tags');
+  if (modalRefs.length === 0) {
+    container.innerHTML = '<span style="color:var(--muted);font-size:.78rem">No references added yet</span>';
+    return;
+  }
+  container.innerHTML = modalRefs.map(ref =>
+    `<span class="ref-tag">${esc(ref)} <button onclick="removeRef('${esc(ref)}')">&times;</button></span>`
+  ).join('');
+}
+
+function resetModal() {
+  document.getElementById('qm-id').value = '';
+  document.getElementById('qm-text').value = '';
+  document.getElementById('qm-type').value = 'allusion';
+  document.getElementById('qm-start').value = '';
+  document.getElementById('qm-end').value = '';
+  document.getElementById('ref-book').value = '';
+  document.getElementById('ref-chapter').innerHTML = '<option value="">Ch.</option>';
+  document.getElementById('ref-chapter').disabled = true;
+  document.getElementById('ref-verses-wrap').style.display = 'none';
+  modalRefs = [];
+  renderRefTags();
+}
+
+function openAddModal() {
+  loadBibleBooks().then(() => {
+    document.getElementById('modal-title').textContent = 'Add Quote';
+    resetModal();
+    quoteModal.classList.add('active');
+  });
+}
+
+function addFromSelection() {
+  if (!selRange) return;
+  selToolbar.classList.remove('visible');
+  loadBibleBooks().then(() => {
+    document.getElementById('modal-title').textContent = 'Add Quote';
+    resetModal();
+    document.getElementById('qm-text').value = selRange.text;
+    document.getElementById('qm-start').value = selRange.start;
+    document.getElementById('qm-end').value = selRange.end;
+    quoteModal.classList.add('active');
+    window.getSelection().removeAllRanges();
+  });
+}
+
+function editQuote(idx) {
+  const a = DATA.annotations[idx];
+  if (!a) return;
+  loadBibleBooks().then(() => {
+    document.getElementById('modal-title').textContent = 'Edit Quote';
+    resetModal();
+    document.getElementById('qm-id').value = a.id;
+    document.getElementById('qm-text').value = a.quote_text;
+    document.getElementById('qm-type').value = a.quote_type;
+    document.getElementById('qm-start').value = a.span_start ?? '';
+    document.getElementById('qm-end').value = a.span_end ?? '';
+    modalRefs = [...(a.refs || [])];
+    renderRefTags();
+    quoteModal.classList.add('active');
+  });
+}
+
+function closeQuoteModal() { quoteModal.classList.remove('active'); }
+
+function saveQuote() {
+  const id = document.getElementById('qm-id').value;
+  const text = document.getElementById('qm-text').value.trim();
+  const type = document.getElementById('qm-type').value;
+  const startVal = document.getElementById('qm-start').value;
+  const endVal = document.getElementById('qm-end').value;
+  const span_start = startVal !== '' ? parseInt(startVal) : null;
+  const span_end = endVal !== '' ? parseInt(endVal) : null;
+
+  if (!text) { showToast('Quote text is required', false); return; }
+
+  const saveBtn = document.getElementById('qm-save');
+  saveBtn.disabled = true;
+
+  const payload = {quote_text: text, quote_type: type, references: modalRefs, span_start, span_end};
+  const url = id ? `/api/quotes/${id}` : '/api/quotes';
+  const method = id ? 'PUT' : 'POST';
+  if (!id) payload.source_id = SOURCE_ID;
+
+  fetch(url, {
+    method,
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify(payload),
+  })
+  .then(r => r.json())
+  .then(() => {
+    closeQuoteModal();
+    showToast(id ? 'Quote updated' : 'Quote added', true);
+    distChartsRendered = false;
+    loadSource();
+  })
+  .catch(e => showToast('Error: ' + e.message, false))
+  .finally(() => { saveBtn.disabled = false; });
+}
+
+function deleteQuote(id) {
+  if (!confirm('Delete this quote?')) return;
+  fetch(`/api/quotes/${id}`, {method: 'DELETE'})
+    .then(() => { showToast('Quote deleted', true); distChartsRendered = false; loadSource(); })
+    .catch(e => showToast('Error: ' + e.message, false));
+}
+
+let bookChart = null, typeChart = null;
+
+function loadDistribution() {
+  fetch(`/api/sources/${SOURCE_ID}/distribution`)
+    .then(r => r.json())
+    .then(data => { renderDistCharts(data); distChartsRendered = true; });
+}
+
+function renderDistCharts(data) {
+  if (bookChart) { bookChart.destroy(); bookChart = null; }
+  if (typeChart) { typeChart.destroy(); typeChart = null; }
+
+  const chartFont = { family: "'Inter', system-ui, sans-serif" };
+  const bookCanvas = document.getElementById('dist-book-chart');
+  const typeCanvas = document.getElementById('dist-type-chart');
+
+  const bd = data.book_distribution || [];
+  if (bd.length > 0) {
+    const colors = bd.map(d => d.testament === 'nt' ? '#6366f1' : d.testament === 'ot' ? '#f59e0b' : '#9ca3af');
+    bookChart = new Chart(bookCanvas, {
+      type: 'bar',
+      data: {
+        labels: bd.map(d => d.book_name || d.book_code),
+        datasets: [{ data: bd.map(d => d.count), backgroundColor: colors, borderRadius: 6 }],
+      },
+      options: {
+        indexAxis: 'y', responsive: true, maintainAspectRatio: false,
+        plugins: { legend: { display: false } },
+        scales: {
+          x: { beginAtZero: true, ticks: { precision: 0, font: chartFont }, grid: { color: '#f0ede7' } },
+          y: { ticks: { font: { ...chartFont, size: 11 } }, grid: { display: false } },
+        },
+      },
+    });
+  }
+
+  const td = data.type_distribution || {};
+  const typeLabels = ['full', 'partial', 'paraphrase', 'allusion'];
+  const typeColors = ['#16a34a', '#ca8a04', '#0891b2', '#9333ea'];
+  const typeData = typeLabels.map(t => td[t] || 0);
+  if (typeData.some(v => v > 0)) {
+    typeChart = new Chart(typeCanvas, {
+      type: 'doughnut',
+      data: {
+        labels: typeLabels.map(t => t.charAt(0).toUpperCase() + t.slice(1)),
+        datasets: [{ data: typeData, backgroundColor: typeColors, borderWidth: 3, borderColor: '#fff', hoverOffset: 8 }],
+      },
+      options: {
+        responsive: true, maintainAspectRatio: false, cutout: '60%',
+        plugins: { legend: { position: 'bottom', labels: { padding: 20, font: { ...chartFont, size: 12 }, usePointStyle: true, pointStyle: 'rectRounded' } } },
+      },
+    });
+  }
+}
+
+quoteModal.addEventListener('click', e => { if (e.target === quoteModal) closeQuoteModal(); });
+loadSource();
+</script>
+</body>
+</html>